@skillkit/tui 1.3.1 → 1.5.0

package/dist/index.js

@@ -2,8 +2,8 @@
 import { render } from "ink";
 
 // src/App.tsx
-import { useState as useState12 } from "react";
-import { Box as Box10, Text as Text10, useInput as useInput8, useApp, useStdout } from "ink";
+import { useState as useState19 } from "react";
+import { Box as Box17, Text as Text17, useInput as useInput15, useApp, useStdout } from "ink";
 
 // src/components/Sidebar.tsx
 import { Box, Text } from "ink";
@@ -27,7 +27,13 @@ var symbols = {
   checkboxOff: chalk.dim("\u2716"),
   check: chalk.white("\u2713"),
   star: "\u2605",
-  spinner: ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"]
+  spinner: ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"],
+  arrowUp: "\u2191",
+  arrowDown: "\u2193",
+  success: "\u2713",
+  error: "\u2717",
+  warning: "\u26A0",
+  info: "\u2139"
 };
 var logo = `
 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2557  \u2588\u2588\u2557\u2588\u2588\u2557\u2588\u2588\u2557     \u2588\u2588\u2557     \u2588\u2588\u2557  \u2588\u2588\u2557\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557
@@ -41,14 +47,26 @@ var logo = `
 // src/components/Sidebar.tsx
 import { jsx, jsxs } from "react/jsx-runtime";
 var NAV = [
-  { id: "home", label: "Home" },
-  { id: "browse", label: "Browse" },
-  { id: "recommend", label: "Recommend" },
-  { id: "translate", label: "Translate" },
-  { id: "context", label: "Context" },
-  { id: "installed", label: "List" },
-  { id: "sync", label: "Sync" },
-  { id: "settings", label: "Config" }
+  // Discovery
+  { id: "home", label: "Home", key: "h" },
+  { id: "marketplace", label: "Marketplace", key: "m" },
+  { id: "browse", label: "Browse", key: "b" },
+  // Execution
+  { id: "workflow", label: "Workflows", key: "w" },
+  { id: "execute", label: "Execute", key: "x" },
+  { id: "history", label: "History", key: "y" },
+  // Collaboration
+  { id: "team", label: "Team", key: "a" },
+  { id: "plugins", label: "Plugins", key: "p" },
+  // Tools
+  { id: "recommend", label: "Recommend", key: "r" },
+  { id: "translate", label: "Translate", key: "t" },
+  { id: "context", label: "Context", key: "c" },
+  { id: "memory", label: "Memory", key: "e" },
+  // Management
+  { id: "installed", label: "Installed", key: "i" },
+  { id: "sync", label: "Sync", key: "s" },
+  { id: "settings", label: "Config", key: "," }
 ];
 function Sidebar({ screen }) {
   return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", width: 14, borderStyle: "single", paddingX: 1, children: [
@@ -58,12 +76,22 @@ function Sidebar({ screen }) {
       item.label
     ] }, item.id)),
     /* @__PURE__ */ jsx(Text, { children: " " }),
-    NAV.slice(3, 5).map((item) => /* @__PURE__ */ jsxs(Text, { inverse: screen === item.id, children: [
+    NAV.slice(3, 6).map((item) => /* @__PURE__ */ jsxs(Text, { inverse: screen === item.id, children: [
       screen === item.id ? symbols.bullet : " ",
       item.label
     ] }, item.id)),
     /* @__PURE__ */ jsx(Text, { children: " " }),
-    NAV.slice(5).map((item) => /* @__PURE__ */ jsxs(Text, { inverse: screen === item.id, children: [
+    NAV.slice(6, 8).map((item) => /* @__PURE__ */ jsxs(Text, { inverse: screen === item.id, children: [
+      screen === item.id ? symbols.bullet : " ",
+      item.label
+    ] }, item.id)),
+    /* @__PURE__ */ jsx(Text, { children: " " }),
+    NAV.slice(8, 12).map((item) => /* @__PURE__ */ jsxs(Text, { inverse: screen === item.id, children: [
+      screen === item.id ? symbols.bullet : " ",
+      item.label
+    ] }, item.id)),
+    /* @__PURE__ */ jsx(Text, { children: " " }),
+    NAV.slice(12).map((item) => /* @__PURE__ */ jsxs(Text, { inverse: screen === item.id, children: [
       screen === item.id ? symbols.bullet : " ",
       item.label
     ] }, item.id)),
@@ -154,14 +182,16 @@ function Home({ cols = 80, rows = 24 }) {
 
 // src/screens/Browse.tsx
 import { useState as useState3 } from "react";
-import { existsSync, mkdirSync, cpSync, rmSync } from "fs";
-import { join as join2 } from "path";
+import { existsSync as existsSync2, mkdirSync, cpSync, rmSync } from "fs";
+import { join as join3 } from "path";
 import { Box as Box3, Text as Text3, useInput } from "ink";
 
 // src/hooks/useMarketplace.ts
 import { useState as useState2, useCallback, useEffect as useEffect2 } from "react";
-import { detectProvider } from "@skillkit/core";
-var POPULAR_REPOS = [
+import { detectProvider, loadConfig, extractFrontmatter } from "@skillkit/core";
+import { readFileSync as readFileSync2, existsSync } from "fs";
+import { join as join2 } from "path";
+var DEFAULT_REPOS = [
   { source: "anthropics/skills", name: "Anthropic Official" },
   { source: "vercel-labs/agent-skills", name: "Vercel Labs" },
   { source: "expo/skills", name: "Expo / React Native" },
@@ -193,6 +223,41 @@ var POPULAR_REPOS = [
   { source: "openrouterteam/agent-skills", name: "OpenRouter SDK" },
   { source: "intellectronica/agent-skills", name: "Context7" }
 ];
+function getMarketplaceRepos() {
+  try {
+    const config = loadConfig();
+    if (config.marketplaceSources?.length) {
+      const configRepos = config.marketplaceSources.map((source) => ({
+        source,
+        name: source.split("/").pop() || source
+      }));
+      const existingSources = new Set(configRepos.map((r) => r.source));
+      for (const repo of DEFAULT_REPOS) {
+        if (!existingSources.has(repo.source)) {
+          configRepos.push(repo);
+        }
+      }
+      return configRepos;
+    }
+  } catch {
+  }
+  return DEFAULT_REPOS;
+}
+function readSkillDescription(skillPath) {
+  const skillMdPath = join2(skillPath, "SKILL.md");
+  if (!existsSync(skillMdPath)) {
+    return void 0;
+  }
+  try {
+    const content = readFileSync2(skillMdPath, "utf-8");
+    const frontmatter = extractFrontmatter(content);
+    if (frontmatter && typeof frontmatter.description === "string") {
+      return frontmatter.description;
+    }
+  } catch {
+  }
+  return void 0;
+}
 function useMarketplace() {
   const [allSkills, setAllSkills] = useState2([]);
   const [filteredSkills, setFilteredSkills] = useState2([]);
@@ -200,6 +265,8 @@ function useMarketplace() {
   const [error, setError] = useState2(null);
   const [currentRepo, setCurrentRepo] = useState2(null);
   const [fetchedRepos, setFetchedRepos] = useState2(/* @__PURE__ */ new Set());
+  const [failedRepos, setFailedRepos] = useState2([]);
+  const [repos] = useState2(() => getMarketplaceRepos());
   const fetchRepo = useCallback(async (source) => {
     if (fetchedRepos.has(source)) return;
     setLoading(true);
@@ -214,12 +281,13 @@ function useMarketplace() {
       if (!result.success || !result.discoveredSkills) {
         throw new Error(result.error || "Failed to fetch skills");
       }
-      const repoName = POPULAR_REPOS.find((r) => r.source === source)?.name || source;
+      const repoName = repos.find((r) => r.source === source)?.name || source;
       const newSkills = result.discoveredSkills.map((skill) => ({
         name: skill.name,
         source,
         repoName,
-        description: void 0
+        // Try to read description from skill frontmatter
+        description: readSkillDescription(skill.path)
       }));
       setAllSkills((prev) => {
         const updated = [...prev, ...newSkills];
@@ -231,27 +299,37 @@ function useMarketplace() {
         rmSync3(result.tempRoot, { recursive: true, force: true });
       }
     } catch (err) {
-      setError(err instanceof Error ? err.message : "Failed to fetch repository");
+      const errorMsg = err instanceof Error ? err.message : "Failed to fetch repository";
+      setError(errorMsg);
+      setFailedRepos((prev) => prev.includes(source) ? prev : [...prev, source]);
     } finally {
       setLoading(false);
       setCurrentRepo(null);
     }
-  }, [fetchedRepos]);
+  }, [fetchedRepos, repos]);
   const fetchAllRepos = useCallback(async () => {
     setLoading(true);
     setError(null);
-    for (const repo of POPULAR_REPOS) {
+    const failures = [];
+    for (const repo of repos) {
       if (!fetchedRepos.has(repo.source)) {
         setCurrentRepo(repo.source);
         try {
           await fetchRepo(repo.source);
-        } catch {
+        } catch (err) {
+          failures.push(repo.source);
         }
       }
     }
+    if (failures.length > 0) {
+      setFailedRepos((prev) => {
+        const combined = [...prev, ...failures];
+        return [...new Set(combined)];
+      });
+    }
     setLoading(false);
     setCurrentRepo(null);
-  }, [fetchRepo, fetchedRepos]);
+  }, [fetchRepo, fetchedRepos, repos]);
   const search = useCallback((query) => {
     if (!query.trim()) {
       setFilteredSkills(allSkills);
@@ -268,6 +346,8 @@ function useMarketplace() {
     setFetchedRepos(/* @__PURE__ */ new Set());
     setAllSkills([]);
     setFilteredSkills([]);
+    setFailedRepos([]);
+    setError(null);
   }, []);
   useEffect2(() => {
     setFilteredSkills(allSkills);
@@ -282,8 +362,9 @@ function useMarketplace() {
     loading,
     error,
     totalCount: allSkills.length,
-    repos: POPULAR_REPOS,
+    repos,
     currentRepo,
+    failedRepos,
     refresh,
     search,
     fetchRepo,
@@ -297,14 +378,14 @@ import { detectAgent, getAdapter as getAdapter2, getAllAdapters } from "@skillki
 
 // src/helpers.ts
 import {
-  loadConfig,
+  loadConfig as loadConfig2,
   getSearchDirs as coreGetSearchDirs,
   getInstallDir as coreGetInstallDir,
   saveSkillMetadata as coreSaveSkillMetadata
 } from "@skillkit/core";
 import { getAdapter } from "@skillkit/agents";
 function getSearchDirs(agentType) {
-  const type = agentType || loadConfig().agent;
+  const type = agentType || loadConfig2().agent;
   const adapter = getAdapter(type);
   const adapterInfo = {
     type: adapter.type,
@@ -315,7 +396,7 @@ function getSearchDirs(agentType) {
   return coreGetSearchDirs(adapterInfo);
 }
 function getInstallDir(global = false, agentType) {
-  const type = agentType || loadConfig().agent;
+  const type = agentType || loadConfig2().agent;
   const adapter = getAdapter(type);
   const adapterInfo = {
     type: adapter.type,
@@ -380,11 +461,11 @@ function Browse({ rows = 24 }) {
       const targetAgentType = agentType || await detectAgent();
       const adapter = getAdapter2(targetAgentType);
       const installDir = getInstallDir(false, targetAgentType);
-      if (!existsSync(installDir)) {
+      if (!existsSync2(installDir)) {
         mkdirSync(installDir, { recursive: true });
       }
-      const targetPath = join2(installDir, skillName);
-      if (existsSync(targetPath)) {
+      const targetPath = join3(installDir, skillName);
+      if (existsSync2(targetPath)) {
         rmSync(targetPath, { recursive: true, force: true });
       }
       cpSync(skill.path, targetPath, { recursive: true, dereference: true });
@@ -690,206 +771,176 @@ function Sync({ rows = 24 }) {
 }
 
 // src/screens/Settings.tsx
-import { useState as useState7 } from "react";
+import { useState as useState7, useEffect as useEffect5 } from "react";
 import { Box as Box6, Text as Text6, useInput as useInput4 } from "ink";
+import TextInput from "ink-text-input";
+import { loadConfig as loadConfig3, saveConfig, AgentType as AgentTypeSchema } from "@skillkit/core";
 import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+var ALL_AGENTS = AgentTypeSchema.options;
 var SETTINGS = [
-  { id: "agent", label: "Default Agent", value: "auto-detect" },
-  { id: "sync", label: "Auto Sync", value: "disabled" },
-  { id: "cache", label: "Cache Dir", value: "~/.skillkit/cache" }
+  { id: "agent", label: "Default Agent", type: "select", options: ["auto-detect", ...ALL_AGENTS] },
+  { id: "autoSync", label: "Auto Sync", type: "toggle" },
+  { id: "cacheDir", label: "Cache Dir", type: "text" }
 ];
-function Settings({}) {
+function Settings(_props) {
+  const [config, setConfig] = useState7(null);
   const [sel, setSel] = useState7(0);
-  useInput4((_, key) => {
-    if (key.upArrow) setSel((i) => Math.max(0, i - 1));
-    else if (key.downArrow) setSel((i) => Math.min(SETTINGS.length - 1, i + 1));
+  const [editing, setEditing] = useState7(false);
+  const [editValue, setEditValue] = useState7("");
+  const [saved, setSaved] = useState7(false);
+  const [error, setError] = useState7(null);
+  useEffect5(() => {
+    try {
+      const loaded = loadConfig3();
+      setConfig(loaded);
+    } catch (err) {
+      setError(`Failed to load config: ${err}`);
+    }
+  }, []);
+  const getCurrentValue = (setting) => {
+    if (!config) return "";
+    switch (setting.id) {
+      case "agent":
+        return config.agent === "universal" ? "auto-detect" : config.agent || "auto-detect";
+      case "autoSync":
+        return config.autoSync ? "enabled" : "disabled";
+      case "cacheDir":
+        return config.cacheDir || "~/.skillkit/cache";
+      default:
+        return "";
+    }
+  };
+  const handleSave = (setting, value) => {
+    if (!config) return;
+    const newConfig = { ...config };
+    switch (setting.id) {
+      case "agent":
+        if (value === "auto-detect") {
+          newConfig.agent = "universal";
+        } else {
+          newConfig.agent = value;
+        }
+        break;
+      case "autoSync":
+        newConfig.autoSync = value === "enabled";
+        break;
+      case "cacheDir":
+        newConfig.cacheDir = value || void 0;
+        break;
+    }
+    try {
+      saveConfig(newConfig, false);
+      setConfig(newConfig);
+      setSaved(true);
+      setTimeout(() => setSaved(false), 2e3);
+    } catch (err) {
+      setError(`Failed to save: ${err}`);
+      setTimeout(() => setError(null), 3e3);
+    }
+  };
+  useInput4((input, key) => {
+    if (editing) {
+      if (key.return) {
+        handleSave(SETTINGS[sel], editValue);
+        setEditing(false);
+      } else if (key.escape) {
+        setEditing(false);
+      }
+      return;
+    }
+    if (key.upArrow) {
+      setSel((i) => Math.max(0, i - 1));
+    } else if (key.downArrow) {
+      setSel((i) => Math.min(SETTINGS.length - 1, i + 1));
+    } else if (key.return || input === " ") {
+      const setting = SETTINGS[sel];
+      if (setting.type === "toggle") {
+        const current = getCurrentValue(setting);
+        const newValue = current === "enabled" ? "disabled" : "enabled";
+        handleSave(setting, newValue);
+      } else if (setting.type === "select" && setting.options) {
+        const current = getCurrentValue(setting);
+        const idx = setting.options.indexOf(current);
+        const nextIdx = (idx + 1) % setting.options.length;
+        handleSave(setting, setting.options[nextIdx]);
+      } else if (setting.type === "text") {
+        setEditValue(getCurrentValue(setting));
+        setEditing(true);
+      }
+    }
   });
+  if (!config) {
+    return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx6(Text6, { bold: true, color: colors.primary, children: "SETTINGS" }),
+      error ? /* @__PURE__ */ jsxs6(Text6, { color: colors.danger, children: [
+        symbols.error,
+        " ",
+        error
+      ] }) : /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "Loading..." })
+    ] });
+  }
   return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", children: [
     /* @__PURE__ */ jsx6(Text6, { bold: true, color: colors.primary, children: "SETTINGS" }),
-    /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "Configure SkillKit" }),
+    /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "Configure SkillKit (changes save automatically)" }),
     /* @__PURE__ */ jsx6(Box6, { marginTop: 1, flexDirection: "column", children: SETTINGS.map((s, i) => {
       const isSel = i === sel;
-      return /* @__PURE__ */ jsxs6(Text6, { inverse: isSel, children: [
-        isSel ? symbols.pointer : " ",
-        s.label.padEnd(16),
-        " ",
-        /* @__PURE__ */ jsx6(Text6, { color: colors.secondaryDim, children: s.value })
+      const value = getCurrentValue(s);
+      const isEditing = editing && isSel;
+      return /* @__PURE__ */ jsxs6(Box6, { children: [
+        /* @__PURE__ */ jsxs6(Text6, { inverse: isSel && !isEditing, children: [
+          isSel ? symbols.pointer : " ",
+          s.label.padEnd(16)
+        ] }),
+        isEditing ? /* @__PURE__ */ jsx6(Box6, { marginLeft: 1, children: /* @__PURE__ */ jsx6(
+          TextInput,
+          {
+            value: editValue,
+            onChange: setEditValue,
+            onSubmit: () => {
+              handleSave(s, editValue);
+              setEditing(false);
+            }
+          }
+        ) }) : /* @__PURE__ */ jsxs6(Text6, { color: colors.secondaryDim, children: [
+          " ",
+          value
+        ] }),
+        s.type === "toggle" && isSel && !isEditing && /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: " (space to toggle)" }),
+        s.type === "select" && isSel && !isEditing && /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: " (enter to cycle)" })
       ] }, s.id);
     }) }),
-    /* @__PURE__ */ jsx6(Box6, { marginTop: 1, children: /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "Enter=edit  q=quit" }) })
+    /* @__PURE__ */ jsxs6(Box6, { marginTop: 1, children: [
+      saved && /* @__PURE__ */ jsxs6(Text6, { color: colors.success, children: [
+        symbols.check,
+        " Settings saved"
+      ] }),
+      error && /* @__PURE__ */ jsxs6(Text6, { color: colors.danger, children: [
+        symbols.error,
+        " ",
+        error
+      ] }),
+      !saved && !error && /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: editing ? "Enter=save  Esc=cancel" : "Enter/Space=edit  q=quit" })
+    ] })
   ] });
 }
 
 // src/screens/Recommend.tsx
 import { useState as useState9 } from "react";
-import { existsSync as existsSync3, mkdirSync as mkdirSync3, cpSync as cpSync2, rmSync as rmSync2 } from "fs";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, cpSync as cpSync2, rmSync as rmSync2 } from "fs";
 import { join as join4 } from "path";
 import { Box as Box7, Text as Text7, useInput as useInput5 } from "ink";
 
 // src/hooks/useRecommend.ts
-import { useState as useState8, useCallback as useCallback2, useEffect as useEffect5 } from "react";
+import { useState as useState8, useCallback as useCallback2, useEffect as useEffect6 } from "react";
 import {
   RecommendationEngine,
-  ContextManager
+  ContextManager,
+  loadIndex as loadIndexFromCache,
+  saveIndex,
+  buildSkillIndex,
+  isIndexStale,
+  KNOWN_SKILL_REPOS
 } from "@skillkit/core";
-import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync, mkdirSync as mkdirSync2 } from "fs";
-import { join as join3 } from "path";
-var INDEX_PATH = join3(process.env.HOME || "~", ".skillkit", "index.json");
-var INDEX_CACHE_HOURS = 24;
-function getSampleSkills() {
-  return [
-    {
-      name: "vercel-react-best-practices",
-      description: "Modern React patterns including Server Components, hooks best practices, and performance optimization",
-      source: "vercel-labs/agent-skills",
-      tags: ["react", "frontend", "typescript", "nextjs", "performance"],
-      compatibility: {
-        frameworks: ["react", "nextjs"],
-        languages: ["typescript", "javascript"],
-        libraries: []
-      },
-      popularity: 1500,
-      quality: 95,
-      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
-      verified: true
-    },
-    {
-      name: "tailwind-v4-patterns",
-      description: "Tailwind CSS v4 utility patterns, responsive design, and component styling best practices",
-      source: "vercel-labs/agent-skills",
-      tags: ["tailwind", "css", "styling", "frontend", "responsive"],
-      compatibility: {
-        frameworks: [],
-        languages: ["typescript", "javascript"],
-        libraries: ["tailwindcss"]
-      },
-      popularity: 1200,
-      quality: 92,
-      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
-      verified: true
-    },
-    {
-      name: "nextjs-app-router",
-      description: "Next.js App Router patterns including layouts, server actions, and data fetching",
-      source: "vercel-labs/agent-skills",
-      tags: ["nextjs", "react", "routing", "server-actions", "frontend"],
-      compatibility: {
-        frameworks: ["nextjs"],
-        languages: ["typescript", "javascript"],
-        libraries: []
-      },
-      popularity: 1100,
-      quality: 94,
-      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
-      verified: true
-    },
-    {
-      name: "typescript-strict-patterns",
-      description: "TypeScript strict mode patterns, type safety, and advanced type utilities",
-      source: "anthropics/skills",
-      tags: ["typescript", "types", "safety", "patterns"],
-      compatibility: {
-        frameworks: [],
-        languages: ["typescript"],
-        libraries: []
-      },
-      popularity: 900,
-      quality: 90,
-      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
-      verified: true
-    },
-    {
-      name: "supabase-best-practices",
-      description: "Supabase integration patterns including auth, database queries, and real-time subscriptions",
-      source: "anthropics/skills",
-      tags: ["supabase", "database", "auth", "backend", "postgresql"],
-      compatibility: {
-        frameworks: [],
-        languages: ["typescript", "javascript"],
-        libraries: ["@supabase/supabase-js"]
-      },
-      popularity: 800,
-      quality: 88,
-      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
-      verified: true
-    },
-    {
-      name: "vitest-testing-patterns",
-      description: "Testing patterns with Vitest including mocking, assertions, and test organization",
-      source: "anthropics/skills",
-      tags: ["vitest", "testing", "typescript", "mocking", "tdd"],
-      compatibility: {
-        frameworks: [],
-        languages: ["typescript", "javascript"],
-        libraries: ["vitest"]
-      },
-      popularity: 700,
-      quality: 86,
-      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
-      verified: false
-    },
-    {
-      name: "prisma-database-patterns",
-      description: "Prisma ORM patterns for schema design, migrations, and efficient queries",
-      source: "vercel-labs/agent-skills",
-      tags: ["prisma", "database", "orm", "postgresql", "backend"],
-      compatibility: {
-        frameworks: [],
-        languages: ["typescript"],
-        libraries: ["@prisma/client"]
-      },
-      popularity: 850,
-      quality: 89,
-      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
-      verified: true
-    },
-    {
-      name: "security-best-practices",
-      description: "Security patterns for web applications including XSS prevention, CSRF, and secure headers",
-      source: "trailofbits/skills",
-      tags: ["security", "xss", "csrf", "headers", "owasp"],
-      compatibility: {
-        frameworks: [],
-        languages: ["typescript", "javascript", "python"],
-        libraries: []
-      },
-      popularity: 600,
-      quality: 95,
-      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
-      verified: true
-    },
-    {
-      name: "python-fastapi-patterns",
-      description: "FastAPI best practices for building high-performance Python APIs",
-      source: "python-skills/fastapi",
-      tags: ["python", "fastapi", "backend", "api", "async"],
-      compatibility: {
-        frameworks: ["fastapi"],
-        languages: ["python"],
-        libraries: []
-      },
-      popularity: 550,
-      quality: 85,
-      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
-      verified: false
-    },
-    {
-      name: "zustand-state-management",
-      description: "Zustand state management patterns for React applications",
-      source: "react-skills/state",
-      tags: ["zustand", "react", "state-management", "frontend"],
-      compatibility: {
-        frameworks: ["react"],
-        languages: ["typescript", "javascript"],
-        libraries: ["zustand"]
-      },
-      popularity: 650,
-      quality: 84,
-      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
-      verified: false
-    }
-  ];
-}
 function useRecommend(projectPath = process.cwd()) {
   const [recommendations, setRecommendations] = useState8([]);
   const [searchResults, setSearchResults] = useState8([]);
@@ -900,25 +951,17 @@ function useRecommend(projectPath = process.cwd()) {
   const [indexStatus, setIndexStatus] = useState8("missing");
   const [engine] = useState8(() => new RecommendationEngine());
   const loadIndex = useCallback2(() => {
-    if (!existsSync2(INDEX_PATH)) {
+    const index = loadIndexFromCache();
+    if (!index) {
       setIndexStatus("missing");
       return null;
     }
-    try {
-      const content = readFileSync2(INDEX_PATH, "utf-8");
-      const index = JSON.parse(content);
-      const lastUpdated = new Date(index.lastUpdated);
-      const hoursSinceUpdate = (Date.now() - lastUpdated.getTime()) / (1e3 * 60 * 60);
-      if (hoursSinceUpdate > INDEX_CACHE_HOURS) {
-        setIndexStatus("stale");
-      } else {
-        setIndexStatus("fresh");
-      }
-      return index;
-    } catch {
-      setIndexStatus("missing");
-      return null;
+    if (isIndexStale(index)) {
+      setIndexStatus("stale");
+    } else {
+      setIndexStatus("fresh");
     }
+    return index;
   }, []);
   const getProjectProfile = useCallback2(() => {
     try {
@@ -978,37 +1021,17 @@ function useRecommend(projectPath = process.cwd()) {
   const updateIndex = useCallback2(() => {
     setLoading(true);
     setError(null);
-    try {
-      const sampleIndex = {
-        version: 1,
-        lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
-        skills: getSampleSkills(),
-        sources: [
-          {
-            name: "vercel-labs",
-            url: "https://github.com/vercel-labs/agent-skills",
-            lastFetched: (/* @__PURE__ */ new Date()).toISOString(),
-            skillCount: 5
-          },
-          {
-            name: "anthropics",
-            url: "https://github.com/anthropics/skills",
-            lastFetched: (/* @__PURE__ */ new Date()).toISOString(),
-            skillCount: 3
-          }
-        ]
-      };
-      const indexDir = join3(process.env.HOME || "~", ".skillkit");
-      if (!existsSync2(indexDir)) {
-        mkdirSync2(indexDir, { recursive: true });
+    buildSkillIndex(KNOWN_SKILL_REPOS).then(({ index, errors }) => {
+      if (errors.length > 0) {
+        console.warn("Index update warnings:", errors);
       }
-      writeFileSync(INDEX_PATH, JSON.stringify(sampleIndex, null, 2));
+      saveIndex(index);
       setIndexStatus("fresh");
       loadRecommendations();
-    } catch (err) {
+    }).catch((err) => {
       setError(err instanceof Error ? err.message : "Failed to update index");
       setLoading(false);
-    }
+    });
   }, [loadRecommendations]);
   const search = useCallback2((query) => {
     if (!query.trim()) {
@@ -1036,7 +1059,7 @@ function useRecommend(projectPath = process.cwd()) {
   const refresh = useCallback2(() => {
     loadRecommendations();
   }, [loadRecommendations]);
-  useEffect5(() => {
+  useEffect6(() => {
     loadRecommendations();
   }, [loadRecommendations]);
   return {
@@ -1127,7 +1150,7 @@ function Recommend({ rows = 24 }) {
       const adapter = getAdapter3(targetAgentType);
       const installDir = getInstallDir(false, targetAgentType);
       if (!existsSync3(installDir)) {
-        mkdirSync3(installDir, { recursive: true });
+        mkdirSync2(installDir, { recursive: true });
       }
       const targetPath = join4(installDir, skillName);
       if (existsSync3(targetPath)) {
@@ -1333,8 +1356,8 @@ function Recommend({ rows = 24 }) {
 }
 
 // src/screens/Translate.tsx
-import { useState as useState10, useEffect as useEffect6 } from "react";
-import { existsSync as existsSync4, readdirSync, readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync4 } from "fs";
+import { useState as useState10, useEffect as useEffect7 } from "react";
+import { existsSync as existsSync4, readdirSync, readFileSync as readFileSync3, writeFileSync, mkdirSync as mkdirSync3 } from "fs";
 import { join as join5 } from "path";
 import { Box as Box8, Text as Text8, useInput as useInput6 } from "ink";
 import {
@@ -1353,7 +1376,7 @@ function Translate({ rows = 24 }) {
   const [preview, setPreview] = useState10("");
   const [result, setResult] = useState10(null);
   const [loading, setLoading] = useState10(false);
-  useEffect6(() => {
+  useEffect7(() => {
     const loadSkills = () => {
       const installDir = getInstallDir(false);
       const foundSkills = [];
@@ -1376,7 +1399,7 @@ function Translate({ rows = 24 }) {
     };
     loadSkills();
   }, []);
-  useEffect6(() => {
+  useEffect7(() => {
     const adapters = getAllAdapters4();
     const supportedAgents = getSupportedTranslationAgents();
     const agentList = adapters.filter((a) => supportedAgents.includes(a.type)).map((a) => ({
@@ -1415,11 +1438,11 @@ function Translate({ rows = 24 }) {
       const adapter = getAdapter4(selectedAgent.type);
       const targetDir = adapter?.skillsDir ? join5(process.cwd(), adapter.skillsDir) : join5(process.cwd(), `.${selectedAgent.type}/skills/`);
       if (!existsSync4(targetDir)) {
-        mkdirSync4(targetDir, { recursive: true });
+        mkdirSync3(targetDir, { recursive: true });
       }
       const filename = translationResult.filename || `${selectedSkill.name}.md`;
       const targetPath = join5(targetDir, filename);
-      writeFileSync2(targetPath, translationResult.content, "utf-8");
+      writeFileSync(targetPath, translationResult.content, "utf-8");
       setResult({
         success: true,
         message: `Translated ${selectedSkill.name} to ${selectedAgent.name} format`,
@@ -1564,7 +1587,7 @@ function Translate({ rows = 24 }) {
 }
 
 // src/screens/Context.tsx
-import { useState as useState11, useEffect as useEffect7 } from "react";
+import { useState as useState11, useEffect as useEffect8 } from "react";
 import { Box as Box9, Text as Text9, useInput as useInput7 } from "ink";
 import {
   loadContext,
@@ -1584,7 +1607,7 @@ function Context({ rows = 24 }) {
   const [message, setMessage] = useState11(null);
   const [error, setError] = useState11(null);
   const projectPath = process.cwd();
-  useEffect7(() => {
+  useEffect8(() => {
     const load = async () => {
       setLoading(true);
       try {
@@ -1812,16 +1835,1132 @@ function Context({ rows = 24 }) {
   ] });
 }
 
-// src/App.tsx
+// src/screens/Workflow.tsx
+import { useState as useState12, useEffect as useEffect9 } from "react";
+import { Box as Box10, Text as Text10, useInput as useInput8 } from "ink";
+import { listWorkflows } from "@skillkit/core";
 import { jsx as jsx10, jsxs as jsxs10 } from "react/jsx-runtime";
+function Workflow({ rows = 24 }) {
+  const [workflows, setWorkflows] = useState12([]);
+  const [loading, setLoading] = useState12(true);
+  const [sel, setSel] = useState12(0);
+  const [running, setRunning] = useState12(null);
+  const [error, setError] = useState12(null);
+  const maxVisible = Math.max(5, rows - 8);
+  const start = Math.max(0, Math.min(sel - Math.floor(maxVisible / 2), workflows.length - maxVisible));
+  const visible = workflows.slice(start, start + maxVisible);
+  useEffect9(() => {
+    loadWorkflows();
+  }, []);
+  const loadWorkflows = () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const wfs = listWorkflows(process.cwd());
+      setWorkflows(wfs);
+    } catch (e) {
+      setError(e instanceof Error ? e.message : "Failed to load workflows");
+    }
+    setLoading(false);
+  };
+  useInput8((input, key) => {
+    if (loading || running) return;
+    if (key.upArrow) setSel((i) => Math.max(0, i - 1));
+    else if (key.downArrow) setSel((i) => Math.min(workflows.length - 1, i + 1));
+    else if (input === "r") loadWorkflows();
+    else if (key.return && workflows[sel]) {
+      setRunning(workflows[sel].name);
+      setTimeout(() => setRunning(null), 2e3);
+    }
+  });
+  return /* @__PURE__ */ jsxs10(Box10, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx10(Text10, { bold: true, color: colors.primary, children: "WORKFLOWS" }),
+    /* @__PURE__ */ jsxs10(Text10, { dimColor: true, children: [
+      workflows.length,
+      " workflow(s) found"
+    ] }),
+    loading && /* @__PURE__ */ jsx10(Text10, { children: "Loading workflows..." }),
+    error && /* @__PURE__ */ jsx10(Text10, { color: "red", children: error }),
+    running && /* @__PURE__ */ jsxs10(Text10, { color: "yellow", children: [
+      "Running: ",
+      running,
+      "..."
+    ] }),
+    !loading && !running && workflows.length === 0 && /* @__PURE__ */ jsxs10(Box10, { marginTop: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ jsx10(Text10, { dimColor: true, children: "No workflows found." }),
+      /* @__PURE__ */ jsx10(Text10, { dimColor: true, children: "Create one with: skillkit workflow create" })
+    ] }),
+    !loading && !running && workflows.length > 0 && /* @__PURE__ */ jsxs10(Box10, { marginTop: 1, flexDirection: "column", children: [
+      start > 0 && /* @__PURE__ */ jsxs10(Text10, { dimColor: true, children: [
+        "  \u2191 ",
+        start,
+        " more"
+      ] }),
+      visible.map((wf, i) => {
+        const idx = start + i;
+        const isSel = idx === sel;
+        return /* @__PURE__ */ jsxs10(Box10, { flexDirection: "column", children: [
+          /* @__PURE__ */ jsxs10(Text10, { inverse: isSel, children: [
+            isSel ? symbols.pointer : " ",
+            " ",
+            wf.name
+          ] }),
+          isSel && wf.description && /* @__PURE__ */ jsxs10(Text10, { dimColor: true, children: [
+            "   ",
+            wf.description
+          ] }),
+          isSel && /* @__PURE__ */ jsxs10(Text10, { dimColor: true, children: [
+            "   ",
+            wf.waves.length,
+            " wave(s), ",
+            wf.waves.reduce((acc, w) => acc + w.skills.length, 0),
+            " skill(s)"
+          ] })
+        ] }, wf.name);
+      }),
+      start + maxVisible < workflows.length && /* @__PURE__ */ jsxs10(Text10, { dimColor: true, children: [
+        "  \u2193 ",
+        workflows.length - start - maxVisible,
+        " more"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx10(Box10, { marginTop: 1, children: /* @__PURE__ */ jsx10(Text10, { dimColor: true, children: "Enter=run  r=refresh  q=quit" }) })
+  ] });
+}
+
+// src/screens/Execute.tsx
+import { useState as useState13, useEffect as useEffect10 } from "react";
+import { Box as Box11, Text as Text11, useInput as useInput9 } from "ink";
+import { createSessionManager } from "@skillkit/core";
+import { jsx as jsx11, jsxs as jsxs11 } from "react/jsx-runtime";
+function Execute({ rows = 24 }) {
+  const [session, setSession] = useState13(null);
+  const [loading, setLoading] = useState13(true);
+  const maxVisible = Math.max(5, rows - 10);
+  useEffect10(() => {
+    loadSession();
+    const interval = setInterval(loadSession, 1e3);
+    return () => clearInterval(interval);
+  }, []);
+  const loadSession = () => {
+    try {
+      const manager = createSessionManager(process.cwd());
+      const state = manager.get();
+      setSession(state);
+    } catch {
+      setSession(null);
+    }
+    setLoading(false);
+  };
+  useInput9((input, _key) => {
+    if (input === "r") loadSession();
+    else if (input === "p" && session?.currentExecution?.status === "running") {
+      const manager = createSessionManager(process.cwd());
+      manager.pause();
+      loadSession();
+    } else if (input === "c" && session?.currentExecution?.status === "paused") {
+      const manager = createSessionManager(process.cwd());
+      manager.resume();
+      loadSession();
+    }
+  });
+  const renderExecution = (exec) => {
+    const completedTasks = exec.tasks.filter((t) => t.status === "completed").length;
+    const failedTasks = exec.tasks.filter((t) => t.status === "failed").length;
+    const progress = exec.totalSteps > 0 ? Math.round(completedTasks / exec.totalSteps * 100) : 0;
+    const statusColor = exec.status === "running" ? "yellow" : exec.status === "completed" ? "green" : exec.status === "paused" ? "blue" : exec.status === "failed" ? "red" : "white";
+    const visibleTasks = exec.tasks.slice(0, maxVisible);
+    return /* @__PURE__ */ jsxs11(Box11, { flexDirection: "column", marginTop: 1, children: [
+      /* @__PURE__ */ jsx11(Text11, { bold: true, children: exec.skillName }),
+      /* @__PURE__ */ jsxs11(Text11, { children: [
+        "Source: ",
+        /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: exec.skillSource })
+      ] }),
+      /* @__PURE__ */ jsxs11(Text11, { children: [
+        "Status: ",
+        /* @__PURE__ */ jsx11(Text11, { color: statusColor, children: exec.status.toUpperCase() })
+      ] }),
+      /* @__PURE__ */ jsxs11(Text11, { children: [
+        "Progress: ",
+        completedTasks,
+        "/",
+        exec.totalSteps,
+        " (",
+        progress,
+        "%)"
+      ] }),
+      /* @__PURE__ */ jsxs11(Box11, { marginY: 1, children: [
+        /* @__PURE__ */ jsx11(Text11, { children: "[" }),
+        /* @__PURE__ */ jsx11(Text11, { color: "green", children: "\u2588".repeat(Math.floor(progress / 5)) }),
+        /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: "\u2591".repeat(20 - Math.floor(progress / 5)) }),
+        /* @__PURE__ */ jsx11(Text11, { children: "]" })
+      ] }),
+      /* @__PURE__ */ jsx11(Text11, { bold: true, children: "Tasks:" }),
+      visibleTasks.map((task, i) => {
+        const icon = task.status === "completed" ? symbols.success : task.status === "failed" ? symbols.error : task.status === "in_progress" ? symbols.warning : task.status === "paused" ? symbols.info : symbols.bullet;
+        const color = task.status === "completed" ? "green" : task.status === "failed" ? "red" : task.status === "in_progress" ? "yellow" : task.status === "paused" ? "blue" : "white";
+        return /* @__PURE__ */ jsxs11(Text11, { color, children: [
+          icon,
+          " ",
+          task.name,
+          " ",
+          task.error && /* @__PURE__ */ jsxs11(Text11, { dimColor: true, children: [
+            "(",
+            task.error,
+            ")"
+          ] })
+        ] }, task.id || i);
+      }),
+      exec.tasks.length > maxVisible && /* @__PURE__ */ jsxs11(Text11, { dimColor: true, children: [
+        "  ... and ",
+        exec.tasks.length - maxVisible,
+        " more"
+      ] }),
+      failedTasks > 0 && /* @__PURE__ */ jsx11(Box11, { marginTop: 1, children: /* @__PURE__ */ jsxs11(Text11, { color: "red", children: [
+        failedTasks,
+        " task(s) failed"
+      ] }) })
+    ] });
+  };
+  return /* @__PURE__ */ jsxs11(Box11, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx11(Text11, { bold: true, color: colors.primary, children: "EXECUTION MONITOR" }),
+    loading && /* @__PURE__ */ jsx11(Text11, { children: "Loading session..." }),
+    !loading && !session?.currentExecution && /* @__PURE__ */ jsxs11(Box11, { marginTop: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: "No active execution." }),
+      /* @__PURE__ */ jsxs11(Text11, { dimColor: true, children: [
+        "Run a skill with: skillkit run ",
+        "<skill>"
+      ] })
+    ] }),
+    !loading && session?.currentExecution && renderExecution(session.currentExecution),
+    /* @__PURE__ */ jsx11(Box11, { marginTop: 1, children: /* @__PURE__ */ jsxs11(Text11, { dimColor: true, children: [
+      session?.currentExecution?.status === "running" ? "p=pause  " : "",
+      session?.currentExecution?.status === "paused" ? "c=continue  " : "",
+      "r=refresh  q=quit"
+    ] }) })
+  ] });
+}
+
+// src/screens/History.tsx
+import { useState as useState14, useEffect as useEffect11 } from "react";
+import { Box as Box12, Text as Text12, useInput as useInput10 } from "ink";
+import { createSessionManager as createSessionManager2 } from "@skillkit/core";
+import { jsx as jsx12, jsxs as jsxs12 } from "react/jsx-runtime";
+function History({ rows = 24 }) {
+  const [history, setHistory] = useState14([]);
+  const [loading, setLoading] = useState14(true);
+  const [sel, setSel] = useState14(0);
+  const [expanded, setExpanded] = useState14(false);
+  const maxVisible = Math.max(5, rows - 8);
+  const start = Math.max(0, Math.min(sel - Math.floor(maxVisible / 2), history.length - maxVisible));
+  const visible = history.slice(start, start + maxVisible);
+  useEffect11(() => {
+    loadHistory();
+  }, []);
+  const loadHistory = () => {
+    setLoading(true);
+    try {
+      const manager = createSessionManager2(process.cwd());
+      const h = manager.getHistory(50);
+      setHistory(h);
+    } catch {
+      setHistory([]);
+    }
+    setLoading(false);
+  };
+  useInput10((input, key) => {
+    if (loading) return;
+    if (key.upArrow) {
+      setSel((i) => Math.max(0, i - 1));
+      setExpanded(false);
+    } else if (key.downArrow) {
+      setSel((i) => Math.min(history.length - 1, i + 1));
+      setExpanded(false);
+    } else if (input === "r") loadHistory();
+    else if (key.return) setExpanded((e) => !e);
+  });
+  const formatDuration = (ms) => {
+    if (ms < 1e3) return `${ms}ms`;
+    if (ms < 6e4) return `${(ms / 1e3).toFixed(1)}s`;
+    return `${(ms / 6e4).toFixed(1)}m`;
+  };
+  const formatDate = (iso) => {
+    const d = new Date(iso);
+    const now = /* @__PURE__ */ new Date();
+    const diff = now.getTime() - d.getTime();
+    if (diff < 6e4) return "Just now";
+    if (diff < 36e5) return `${Math.floor(diff / 6e4)}m ago`;
+    if (diff < 864e5) return `${Math.floor(diff / 36e5)}h ago`;
+    return d.toLocaleDateString();
+  };
+  return /* @__PURE__ */ jsxs12(Box12, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx12(Text12, { bold: true, color: colors.primary, children: "EXECUTION HISTORY" }),
+    /* @__PURE__ */ jsxs12(Text12, { dimColor: true, children: [
+      history.length,
+      " execution(s)"
+    ] }),
+    loading && /* @__PURE__ */ jsx12(Text12, { children: "Loading history..." }),
+    !loading && history.length === 0 && /* @__PURE__ */ jsxs12(Box12, { marginTop: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ jsx12(Text12, { dimColor: true, children: "No execution history." }),
+      /* @__PURE__ */ jsxs12(Text12, { dimColor: true, children: [
+        "Run a skill with: skillkit run ",
+        "<skill>"
+      ] })
+    ] }),
+    !loading && history.length > 0 && /* @__PURE__ */ jsxs12(Box12, { marginTop: 1, flexDirection: "column", children: [
+      start > 0 && /* @__PURE__ */ jsxs12(Text12, { dimColor: true, children: [
+        "  \u2191 ",
+        start,
+        " more"
+      ] }),
+      visible.map((entry, i) => {
+        const idx = start + i;
+        const isSel = idx === sel;
+        const icon = entry.status === "completed" ? symbols.success : entry.status === "failed" ? symbols.error : symbols.warning;
+        const color = entry.status === "completed" ? "green" : entry.status === "failed" ? "red" : "yellow";
+        return /* @__PURE__ */ jsxs12(Box12, { flexDirection: "column", children: [
+          /* @__PURE__ */ jsxs12(Text12, { inverse: isSel, children: [
+            isSel ? symbols.pointer : " ",
+            /* @__PURE__ */ jsx12(Text12, { color, children: icon }),
+            " ",
+            entry.skillName.padEnd(25),
+            " ",
+            formatDate(entry.completedAt).padEnd(12),
+            " ",
+            formatDuration(entry.durationMs)
+          ] }),
+          isSel && expanded && /* @__PURE__ */ jsxs12(Box12, { flexDirection: "column", marginLeft: 3, children: [
+            /* @__PURE__ */ jsxs12(Text12, { dimColor: true, children: [
+              "Source: ",
+              entry.skillSource
+            ] }),
+            /* @__PURE__ */ jsxs12(Text12, { dimColor: true, children: [
+              "Status: ",
+              entry.status
+            ] }),
+            entry.commits.length > 0 && /* @__PURE__ */ jsxs12(Text12, { dimColor: true, children: [
+              "Commits: ",
+              entry.commits.join(", ")
+            ] }),
+            entry.filesModified.length > 0 && /* @__PURE__ */ jsxs12(Text12, { dimColor: true, children: [
+              "Files: ",
+              entry.filesModified.length,
+              " modified"
+            ] }),
+            entry.error && /* @__PURE__ */ jsxs12(Text12, { color: "red", children: [
+              "Error: ",
+              entry.error
+            ] })
+          ] })
+        ] }, idx);
+      }),
+      start + maxVisible < history.length && /* @__PURE__ */ jsxs12(Text12, { dimColor: true, children: [
+        "  \u2193 ",
+        history.length - start - maxVisible,
+        " more"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx12(Box12, { marginTop: 1, children: /* @__PURE__ */ jsx12(Text12, { dimColor: true, children: "Enter=expand  r=refresh  q=quit" }) })
+  ] });
+}
+
+// src/screens/Marketplace.tsx
+import { useState as useState15, useEffect as useEffect12 } from "react";
+import { Box as Box13, Text as Text13, useInput as useInput11 } from "ink";
+import { jsx as jsx13, jsxs as jsxs13 } from "react/jsx-runtime";
+var SKILL_SOURCES = [
+  { owner: "composioHQ", repo: "awesome-claude-code-skills", name: "Composio Curated" },
+  { owner: "anthropics", repo: "courses", name: "Anthropic Official" }
+];
+function Marketplace({ rows = 24 }) {
+  const [skills, setSkills] = useState15([]);
+  const [loading, setLoading] = useState15(true);
+  const [error, setError] = useState15(null);
+  const [sel, setSel] = useState15(0);
+  const [search, setSearch] = useState15("");
+  const [installing, setInstalling] = useState15(null);
+  const filtered = skills.filter(
+    (s) => s.name.toLowerCase().includes(search.toLowerCase()) || s.description.toLowerCase().includes(search.toLowerCase()) || s.tags?.some((t) => t.toLowerCase().includes(search.toLowerCase()))
+  );
+  const maxVisible = Math.max(5, rows - 10);
+  const start = Math.max(0, Math.min(sel - Math.floor(maxVisible / 2), filtered.length - maxVisible));
+  const visible = filtered.slice(start, start + maxVisible);
+  useEffect12(() => {
+    loadMarketplace();
+  }, []);
+  const loadMarketplace = async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const allSkills = [];
+      for (const source of SKILL_SOURCES) {
+        try {
+          const indexUrl = `https://raw.githubusercontent.com/${source.owner}/${source.repo}/main/skills.json`;
+          const response = await fetch(indexUrl);
+          if (response.ok) {
+            const data = await response.json();
+            if (Array.isArray(data)) {
+              allSkills.push(...data.map((s) => ({
+                name: String(s.name || "Unknown"),
+                description: String(s.description || ""),
+                source: source.name,
+                repo: `${source.owner}/${source.repo}`,
+                tags: Array.isArray(s.tags) ? s.tags : [],
+                stars: typeof s.stars === "number" ? s.stars : void 0
+              })));
+            }
+          } else {
+            allSkills.push({
+              name: source.repo,
+              description: `Skills from ${source.name}`,
+              source: source.name,
+              repo: `${source.owner}/${source.repo}`
+            });
+          }
+        } catch {
+          allSkills.push({
+            name: source.repo,
+            description: `Skills from ${source.name}`,
+            source: source.name,
+            repo: `${source.owner}/${source.repo}`
+          });
+        }
+      }
+      if (allSkills.length === 0) {
+        allSkills.push(
+          { name: "typescript-strict", description: "Enable strict TypeScript mode", source: "Built-in", repo: "skillkit/skills", tags: ["typescript", "config"] },
+          { name: "eslint-setup", description: "Set up ESLint with recommended rules", source: "Built-in", repo: "skillkit/skills", tags: ["eslint", "linting"] },
+          { name: "prettier-config", description: "Configure Prettier formatting", source: "Built-in", repo: "skillkit/skills", tags: ["prettier", "formatting"] },
+          { name: "jest-setup", description: "Set up Jest testing framework", source: "Built-in", repo: "skillkit/skills", tags: ["jest", "testing"] },
+          { name: "nextjs-auth", description: "Add authentication to Next.js", source: "Community", repo: "community/skills", tags: ["nextjs", "auth"] }
+        );
+      }
+      setSkills(allSkills);
+    } catch (e) {
+      setError(e instanceof Error ? e.message : "Failed to load marketplace");
+    }
+    setLoading(false);
+  };
+  useInput11((input, key) => {
+    if (loading || installing) return;
+    if (key.upArrow) setSel((i) => Math.max(0, i - 1));
+    else if (key.downArrow) setSel((i) => Math.min(filtered.length - 1, i + 1));
+    else if (input === "r") loadMarketplace();
+    else if (input === "/") setSearch("");
+    else if (key.backspace || key.delete) setSearch((s) => s.slice(0, -1));
+    else if (key.return && filtered[sel]) {
+      setInstalling(filtered[sel].name);
+      setTimeout(() => setInstalling(null), 1500);
+    } else if (input.length === 1 && /[a-zA-Z0-9-_]/.test(input)) {
+      setSearch((s) => s + input);
+      setSel(0);
+    }
+  });
+  return /* @__PURE__ */ jsxs13(Box13, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx13(Text13, { bold: true, color: colors.primary, children: "SKILL MARKETPLACE" }),
+    /* @__PURE__ */ jsxs13(Text13, { dimColor: true, children: [
+      skills.length,
+      " skills from ",
+      SKILL_SOURCES.length,
+      " sources"
+    ] }),
+    search && /* @__PURE__ */ jsxs13(Text13, { children: [
+      "Search: ",
+      /* @__PURE__ */ jsx13(Text13, { color: "yellow", children: search }),
+      " (",
+      filtered.length,
+      " results)"
+    ] }),
+    loading && /* @__PURE__ */ jsx13(Text13, { children: "Loading marketplace..." }),
+    error && /* @__PURE__ */ jsx13(Text13, { color: "red", children: error }),
+    installing && /* @__PURE__ */ jsxs13(Text13, { color: "yellow", children: [
+      "Installing ",
+      installing,
+      "..."
+    ] }),
+    !loading && !installing && filtered.length === 0 && /* @__PURE__ */ jsx13(Box13, { marginTop: 1, children: /* @__PURE__ */ jsxs13(Text13, { dimColor: true, children: [
+      "No skills found",
+      search ? ` matching "${search}"` : "",
+      "."
+    ] }) }),
+    !loading && !installing && filtered.length > 0 && /* @__PURE__ */ jsxs13(Box13, { marginTop: 1, flexDirection: "column", children: [
+      start > 0 && /* @__PURE__ */ jsxs13(Text13, { dimColor: true, children: [
+        "  \u2191 ",
+        start,
+        " more"
+      ] }),
+      visible.map((skill, i) => {
+        const idx = start + i;
+        const isSel = idx === sel;
+        return /* @__PURE__ */ jsxs13(Box13, { flexDirection: "column", children: [
+          /* @__PURE__ */ jsxs13(Text13, { inverse: isSel, children: [
+            isSel ? symbols.pointer : " ",
+            " ",
+            skill.name.padEnd(25),
+            " ",
+            /* @__PURE__ */ jsx13(Text13, { dimColor: true, children: skill.source })
+          ] }),
+          isSel && /* @__PURE__ */ jsxs13(Box13, { flexDirection: "column", marginLeft: 3, children: [
+            /* @__PURE__ */ jsx13(Text13, { dimColor: true, children: skill.description }),
+            skill.tags && skill.tags.length > 0 && /* @__PURE__ */ jsxs13(Text13, { dimColor: true, children: [
+              "Tags: ",
+              skill.tags.join(", ")
+            ] }),
+            /* @__PURE__ */ jsxs13(Text13, { dimColor: true, children: [
+              "Repo: ",
+              skill.repo
+            ] })
+          ] })
+        ] }, `${skill.repo}/${skill.name}`);
+      }),
+      start + maxVisible < filtered.length && /* @__PURE__ */ jsxs13(Text13, { dimColor: true, children: [
+        "  \u2193 ",
+        filtered.length - start - maxVisible,
+        " more"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx13(Box13, { marginTop: 1, children: /* @__PURE__ */ jsx13(Text13, { dimColor: true, children: "Enter=install  type=search  r=refresh  q=quit" }) })
+  ] });
+}
+
+// src/screens/Memory.tsx
+import { useState as useState16, useEffect as useEffect13 } from "react";
+import { Box as Box14, Text as Text14, useInput as useInput12 } from "ink";
+import {
+  ObservationStore,
+  LearningStore,
+  getMemoryStatus,
+  getMemoryPaths,
+  createMemoryInjector
+} from "@skillkit/core";
+import { jsx as jsx14, jsxs as jsxs14 } from "react/jsx-runtime";
+function Memory({ rows = 24 }) {
+  const [tab, setTab] = useState16("learnings");
+  const [learnings, setLearnings] = useState16([]);
+  const [observationCount, setObservationCount] = useState16(0);
+  const [globalCount, setGlobalCount] = useState16(0);
+  const [loading, setLoading] = useState16(true);
+  const [sel, setSel] = useState16(0);
+  const [expanded, setExpanded] = useState16(false);
+  const [searchQuery, setSearchQuery] = useState16("");
+  const [searchResults, setSearchResults] = useState16([]);
+  const [isGlobal, setIsGlobal] = useState16(false);
+  const maxVisible = Math.max(5, rows - 10);
+  const currentList = tab === "search" ? searchResults : learnings;
+  const start = Math.max(0, Math.min(sel - Math.floor(maxVisible / 2), currentList.length - maxVisible));
+  const visible = currentList.slice(start, start + maxVisible);
+  useEffect13(() => {
+    loadMemory();
+  }, [isGlobal]);
+  const loadMemory = () => {
+    setLoading(true);
+    try {
+      const projectPath = process.cwd();
+      const status = getMemoryStatus(projectPath);
+      const store = new LearningStore(
+        isGlobal ? "global" : "project",
+        isGlobal ? void 0 : projectPath
+      );
+      setLearnings(store.getAll());
+      if (status.hasObservations) {
+        const obsStore = new ObservationStore(projectPath);
+        setObservationCount(obsStore.count());
+      } else {
+        setObservationCount(0);
+      }
+      if (status.hasGlobalLearnings) {
+        const globalStore = new LearningStore("global");
+        setGlobalCount(globalStore.count());
+      } else {
+        setGlobalCount(0);
+      }
+    } catch {
+      setLearnings([]);
+      setObservationCount(0);
+      setGlobalCount(0);
+    }
+    setLoading(false);
+  };
+  const handleSearch = (query) => {
+    if (!query.trim()) {
+      setSearchResults([]);
+      return;
+    }
+    try {
+      const projectPath = process.cwd();
+      const injector = createMemoryInjector(projectPath);
+      const results = injector.search(query, {
+        includeGlobal: true,
+        maxLearnings: 20,
+        minRelevance: 0
+      });
+      setSearchResults(results.map((r) => r.learning));
+    } catch {
+      setSearchResults([]);
+    }
+  };
+  useInput12((input, key) => {
+    if (loading) return;
+    if (input === "1") {
+      setTab("learnings");
+      setSel(0);
+      setExpanded(false);
+    } else if (input === "2") {
+      setTab("observations");
+      setSel(0);
+      setExpanded(false);
+    } else if (input === "3") {
+      setTab("search");
+      setSel(0);
+      setExpanded(false);
+    } else if (key.upArrow) {
+      setSel((i) => Math.max(0, i - 1));
+      setExpanded(false);
+    } else if (key.downArrow) {
+      setSel((i) => Math.min(currentList.length - 1, i + 1));
+      setExpanded(false);
+    } else if (input === "f") loadMemory();
+    else if (input === "g") setIsGlobal((g) => !g);
+    else if (key.return) setExpanded((e) => !e);
+    else if (tab === "search" && input && input.length === 1 && !key.ctrl && !key.meta) {
+      const newQuery = searchQuery + input;
+      setSearchQuery(newQuery);
+      handleSearch(newQuery);
+    } else if (tab === "search" && key.backspace) {
+      const newQuery = searchQuery.slice(0, -1);
+      setSearchQuery(newQuery);
+      handleSearch(newQuery);
+    }
+  });
+  const ONE_MINUTE = 6e4;
+  const ONE_HOUR = 36e5;
+  const ONE_DAY = 864e5;
+  function formatDate(iso) {
+    const d = new Date(iso);
+    const diff = Date.now() - d.getTime();
+    if (diff < ONE_MINUTE) return "Just now";
+    if (diff < ONE_HOUR) return `${Math.floor(diff / ONE_MINUTE)}m ago`;
+    if (diff < ONE_DAY) return `${Math.floor(diff / ONE_HOUR)}h ago`;
+    return d.toLocaleDateString();
+  }
+  function formatEffectiveness(eff) {
+    if (eff === void 0) return "  -";
+    return eff.toString().padStart(3) + "%";
+  }
+  function getEffectivenessColor(eff) {
+    if (eff === void 0) return void 0;
+    if (eff >= 70) return "green";
+    if (eff >= 40) return "yellow";
+    return "red";
+  }
+  const renderLearnings = () => /* @__PURE__ */ jsxs14(Box14, { flexDirection: "column", children: [
+    currentList.length === 0 && /* @__PURE__ */ jsxs14(Box14, { marginTop: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ jsx14(Text14, { dimColor: true, children: "No learnings found." }),
+      /* @__PURE__ */ jsx14(Text14, { dimColor: true, children: "Run skills to capture learnings, or add manually:" }),
+      /* @__PURE__ */ jsx14(Text14, { dimColor: true, children: '  skillkit memory add --title "..." --content "..."' })
+    ] }),
+    currentList.length > 0 && /* @__PURE__ */ jsxs14(Box14, { marginTop: 1, flexDirection: "column", children: [
+      start > 0 && /* @__PURE__ */ jsxs14(Text14, { dimColor: true, children: [
+        "  ",
+        symbols.arrowUp,
+        " ",
+        start,
+        " more"
+      ] }),
+      visible.map((learning, i) => {
+        const idx = start + i;
+        const isSel = idx === sel;
+        return /* @__PURE__ */ jsxs14(Box14, { flexDirection: "column", children: [
+          /* @__PURE__ */ jsxs14(Text14, { inverse: isSel, children: [
+            isSel ? symbols.pointer : " ",
+            /* @__PURE__ */ jsx14(Text14, { color: colors.primary, children: symbols.bullet }),
+            " ",
+            learning.title.slice(0, 35).padEnd(35),
+            " ",
+            /* @__PURE__ */ jsx14(Text14, { dimColor: true, children: learning.tags.slice(0, 2).join(", ").slice(0, 15).padEnd(15) }),
+            " ",
+            /* @__PURE__ */ jsx14(Text14, { color: getEffectivenessColor(learning.effectiveness), children: formatEffectiveness(learning.effectiveness) }),
+            " ",
+            /* @__PURE__ */ jsx14(Text14, { dimColor: true, children: formatDate(learning.updatedAt) })
+          ] }),
+          isSel && expanded && /* @__PURE__ */ jsxs14(Box14, { flexDirection: "column", marginLeft: 3, marginY: 1, children: [
+            /* @__PURE__ */ jsxs14(Text14, { dimColor: true, children: [
+              "ID: ",
+              learning.id.slice(0, 8)
+            ] }),
+            /* @__PURE__ */ jsxs14(Text14, { dimColor: true, children: [
+              "Scope: ",
+              learning.scope
+            ] }),
+            /* @__PURE__ */ jsxs14(Text14, { dimColor: true, children: [
+              "Source: ",
+              learning.source
+            ] }),
+            /* @__PURE__ */ jsxs14(Text14, { dimColor: true, children: [
+              "Tags: ",
+              learning.tags.join(", ")
+            ] }),
+            learning.frameworks && learning.frameworks.length > 0 && /* @__PURE__ */ jsxs14(Text14, { dimColor: true, children: [
+              "Frameworks: ",
+              learning.frameworks.join(", ")
+            ] }),
+            /* @__PURE__ */ jsxs14(Text14, { dimColor: true, children: [
+              "Uses: ",
+              learning.useCount
+            ] }),
+            /* @__PURE__ */ jsx14(Box14, { marginTop: 1, children: /* @__PURE__ */ jsxs14(Text14, { wrap: "wrap", children: [
+              learning.content.slice(0, 300),
+              learning.content.length > 300 ? "..." : ""
+            ] }) })
+          ] })
+        ] }, learning.id);
+      }),
+      start + maxVisible < currentList.length && /* @__PURE__ */ jsxs14(Text14, { dimColor: true, children: [
+        "  ",
+        symbols.arrowDown,
+        " ",
+        currentList.length - start - maxVisible,
+        " more"
+      ] })
+    ] })
+  ] });
+  const renderObservations = () => /* @__PURE__ */ jsxs14(Box14, { flexDirection: "column", marginTop: 1, children: [
+    /* @__PURE__ */ jsxs14(Text14, { children: [
+      "Session Observations: ",
+      /* @__PURE__ */ jsx14(Text14, { bold: true, color: colors.primary, children: observationCount })
+    ] }),
+    /* @__PURE__ */ jsx14(Text14, { dimColor: true, children: "Observations are raw captures from skill execution." }),
+    observationCount > 0 && /* @__PURE__ */ jsxs14(Box14, { marginTop: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ jsx14(Text14, { children: "Compress observations into learnings:" }),
+      /* @__PURE__ */ jsx14(Text14, { dimColor: true, children: "  skillkit memory compress" })
+    ] }),
+    observationCount >= 50 && /* @__PURE__ */ jsx14(Box14, { marginTop: 1, children: /* @__PURE__ */ jsxs14(Text14, { color: "yellow", children: [
+      symbols.warning,
+      " You have many uncompressed observations."
+    ] }) }),
+    /* @__PURE__ */ jsx14(Box14, { marginTop: 1, children: /* @__PURE__ */ jsx14(Text14, { dimColor: true, children: "Observations are stored at:" }) }),
+    /* @__PURE__ */ jsxs14(Text14, { dimColor: true, children: [
+      "  ",
+      getMemoryPaths(process.cwd()).observationsFile
+    ] })
+  ] });
+  const renderSearch = () => /* @__PURE__ */ jsxs14(Box14, { flexDirection: "column", marginTop: 1, children: [
+    /* @__PURE__ */ jsxs14(Box14, { children: [
+      /* @__PURE__ */ jsx14(Text14, { children: "Search: " }),
+      /* @__PURE__ */ jsx14(Text14, { color: colors.primary, children: searchQuery }),
+      /* @__PURE__ */ jsx14(Text14, { color: colors.secondary, children: "_" })
+    ] }),
+    searchQuery && searchResults.length === 0 && /* @__PURE__ */ jsx14(Box14, { marginTop: 1, children: /* @__PURE__ */ jsxs14(Text14, { dimColor: true, children: [
+      'No results found for "',
+      searchQuery,
+      '"'
+    ] }) }),
+    searchResults.length > 0 && renderLearnings()
+  ] });
+  return /* @__PURE__ */ jsxs14(Box14, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx14(Text14, { bold: true, color: colors.primary, children: "MEMORY" }),
+    /* @__PURE__ */ jsxs14(Text14, { dimColor: true, children: [
+      isGlobal ? "Global" : "Project",
+      ": ",
+      learnings.length,
+      " learning(s)",
+      !isGlobal && globalCount > 0 && /* @__PURE__ */ jsxs14(Text14, { children: [
+        " | Global: ",
+        globalCount
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs14(Box14, { marginTop: 1, children: [
+      /* @__PURE__ */ jsx14(Text14, { inverse: tab === "learnings", children: "[1] Learnings" }),
+      /* @__PURE__ */ jsx14(Text14, { children: " " }),
+      /* @__PURE__ */ jsx14(Text14, { inverse: tab === "observations", children: "[2] Observations" }),
+      /* @__PURE__ */ jsx14(Text14, { children: " " }),
+      /* @__PURE__ */ jsx14(Text14, { inverse: tab === "search", children: "[3] Search" })
+    ] }),
+    loading && /* @__PURE__ */ jsx14(Box14, { marginTop: 1, children: /* @__PURE__ */ jsx14(Text14, { children: "Loading..." }) }),
+    !loading && tab === "learnings" && renderLearnings(),
+    !loading && tab === "observations" && renderObservations(),
+    !loading && tab === "search" && renderSearch(),
+    /* @__PURE__ */ jsx14(Box14, { marginTop: 1, children: /* @__PURE__ */ jsx14(Text14, { dimColor: true, children: "Enter=expand  g=toggle global  f=refresh  1-3=tabs" }) })
+  ] });
+}
+
+// src/screens/Team.tsx
+import { useState as useState17, useEffect as useEffect14 } from "react";
+import { Box as Box15, Text as Text15, useInput as useInput13 } from "ink";
+import { jsx as jsx15, jsxs as jsxs15 } from "react/jsx-runtime";
+function Team({ rows = 24 }) {
+  const [config, setConfig] = useState17(null);
+  const [skills, setSkills] = useState17([]);
+  const [loading, setLoading] = useState17(true);
+  const [error, setError] = useState17(null);
+  const [sel, setSel] = useState17(0);
+  const [message, setMessage] = useState17(null);
+  const maxVisible = Math.max(5, rows - 12);
+  const start = Math.max(0, Math.min(sel - Math.floor(maxVisible / 2), skills.length - maxVisible));
+  const visible = skills.slice(start, start + maxVisible);
+  useEffect14(() => {
+    loadTeam();
+  }, []);
+  const loadTeam = async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const { createTeamManager } = await import("@skillkit/core");
+      const manager = createTeamManager(process.cwd());
+      const teamConfig = manager.load();
+      if (!teamConfig) {
+        setConfig(null);
+        setSkills([]);
+        setError("Team not initialized. Run `skillkit team init` first.");
+      } else {
+        setConfig(teamConfig);
+        const sharedSkills = manager.listSharedSkills();
+        setSkills(sharedSkills);
+        setSel((s) => Math.min(s, Math.max(0, sharedSkills.length - 1)));
+      }
+    } catch (e) {
+      setError(e instanceof Error ? e.message : "Failed to load team");
+    }
+    setLoading(false);
+  };
+  const syncTeam = async () => {
+    if (!config) return;
+    setLoading(true);
+    setMessage(null);
+    try {
+      const { createTeamManager } = await import("@skillkit/core");
+      const manager = createTeamManager(process.cwd());
+      manager.load();
+      const result = await manager.sync();
+      const changes = [...result.added, ...result.updated];
+      if (changes.length > 0) {
+        setMessage(`Synced: ${changes.join(", ")}`);
+      } else {
+        setMessage("Already up to date");
+      }
+      const sharedSkills = manager.listSharedSkills();
+      setSkills(sharedSkills);
+      setSel((s) => Math.min(s, Math.max(0, sharedSkills.length - 1)));
+    } catch (e) {
+      setError(e instanceof Error ? e.message : "Sync failed");
+    }
+    setLoading(false);
+  };
+  const importSkill = async (skillName) => {
+    if (!config) return;
+    setLoading(true);
+    setMessage(null);
+    try {
+      const { createTeamManager } = await import("@skillkit/core");
+      const manager = createTeamManager(process.cwd());
+      manager.load();
+      const result = await manager.importSkill(skillName, { overwrite: false });
+      if (result.success) {
+        setMessage(`Imported: ${skillName}`);
+      } else {
+        setError(result.error || "Import failed");
+      }
+    } catch (e) {
+      setError(e instanceof Error ? e.message : "Import failed");
+    }
+    setLoading(false);
+  };
+  useInput13((input, key) => {
+    if (loading) return;
+    if (skills.length === 0 && (key.upArrow || key.downArrow)) return;
+    if (key.upArrow) setSel((i) => Math.max(0, i - 1));
+    else if (key.downArrow) setSel((i) => Math.min(Math.max(0, skills.length - 1), i + 1));
+    else if (input === "r") loadTeam();
+    else if (input === "s") syncTeam();
+    else if (key.return && skills[sel]) {
+      importSkill(skills[sel].name);
+    }
+  });
+  if (loading) {
+    return /* @__PURE__ */ jsxs15(Box15, { flexDirection: "column", padding: 1, children: [
+      /* @__PURE__ */ jsx15(Text15, { color: colors.primary, bold: true, children: "Team Collaboration" }),
+      /* @__PURE__ */ jsx15(Box15, { marginTop: 1, children: /* @__PURE__ */ jsxs15(Text15, { color: colors.secondaryDim, children: [
+        symbols.spinner[0],
+        " Loading..."
+      ] }) })
+    ] });
+  }
+  if (!config) {
+    return /* @__PURE__ */ jsxs15(Box15, { flexDirection: "column", padding: 1, children: [
+      /* @__PURE__ */ jsx15(Text15, { color: colors.primary, bold: true, children: "Team Collaboration" }),
+      /* @__PURE__ */ jsxs15(Box15, { marginTop: 1, flexDirection: "column", children: [
+        /* @__PURE__ */ jsxs15(Text15, { color: colors.secondaryDim, children: [
+          symbols.warning,
+          " Team not initialized"
+        ] }),
+        /* @__PURE__ */ jsx15(Text15, { color: colors.secondaryDim, dimColor: true, children: 'Run: skillkit team init --name "Team Name" --registry <url>' })
+      ] }),
+      /* @__PURE__ */ jsx15(Box15, { marginTop: 1, children: /* @__PURE__ */ jsx15(Text15, { dimColor: true, children: "[r] Refresh" }) })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs15(Box15, { flexDirection: "column", padding: 1, children: [
+    /* @__PURE__ */ jsxs15(Text15, { color: colors.primary, bold: true, children: [
+      "Team: ",
+      config.teamName
+    ] }),
+    /* @__PURE__ */ jsxs15(Text15, { color: colors.secondaryDim, dimColor: true, children: [
+      "Registry: ",
+      config.registryUrl
+    ] }),
+    error && /* @__PURE__ */ jsx15(Box15, { marginTop: 1, children: /* @__PURE__ */ jsxs15(Text15, { color: "red", children: [
+      symbols.error,
+      " ",
+      error
+    ] }) }),
+    message && /* @__PURE__ */ jsx15(Box15, { marginTop: 1, children: /* @__PURE__ */ jsxs15(Text15, { color: "green", children: [
+      symbols.success,
+      " ",
+      message
+    ] }) }),
+    /* @__PURE__ */ jsxs15(Box15, { marginTop: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs15(Text15, { color: colors.secondaryDim, bold: true, children: [
+        "Shared Skills (",
+        skills.length,
+        ")"
+      ] }),
+      skills.length === 0 ? /* @__PURE__ */ jsx15(Text15, { color: colors.secondaryDim, dimColor: true, children: "No shared skills. Use `skillkit team share --name <skill>` to share." }) : /* @__PURE__ */ jsx15(Box15, { flexDirection: "column", marginTop: 1, children: visible.map((skill, i) => {
+        const actualIndex = start + i;
+        const isSelected = actualIndex === sel;
+        return /* @__PURE__ */ jsxs15(Box15, { flexDirection: "column", children: [
+          /* @__PURE__ */ jsxs15(Text15, { children: [
+            isSelected ? symbols.pointer : " ",
+            " ",
+            /* @__PURE__ */ jsx15(Text15, { color: isSelected ? colors.primary : colors.secondaryDim, bold: isSelected, children: skill.name }),
+            /* @__PURE__ */ jsxs15(Text15, { dimColor: true, children: [
+              " v",
+              skill.version
+            ] }),
+            /* @__PURE__ */ jsxs15(Text15, { dimColor: true, children: [
+              " by ",
+              skill.author
+            ] }),
+            skill.downloads !== void 0 && /* @__PURE__ */ jsxs15(Text15, { dimColor: true, children: [
+              " | ",
+              skill.downloads,
+              " downloads"
+            ] })
+          ] }),
+          skill.description && isSelected && /* @__PURE__ */ jsxs15(Text15, { color: colors.secondaryDim, dimColor: true, children: [
+            "    ",
+            skill.description
+          ] })
+        ] }, skill.name);
+      }) })
+    ] }),
+    /* @__PURE__ */ jsx15(Box15, { marginTop: 1, borderStyle: "single", borderColor: colors.borderDim, paddingX: 1, children: /* @__PURE__ */ jsx15(Text15, { dimColor: true, children: "[\u2191\u2193] Navigate  [Enter] Import  [s] Sync  [r] Refresh" }) })
+  ] });
+}
+
+// src/screens/Plugins.tsx
+import { useState as useState18, useEffect as useEffect15 } from "react";
+import { Box as Box16, Text as Text16, useInput as useInput14 } from "ink";
+import { jsx as jsx16, jsxs as jsxs16 } from "react/jsx-runtime";
+function Plugins({ rows = 24 }) {
+  const [plugins, setPlugins] = useState18([]);
+  const [loading, setLoading] = useState18(true);
+  const [error, setError] = useState18(null);
+  const [sel, setSel] = useState18(0);
+  const [message, setMessage] = useState18(null);
+  const maxVisible = Math.max(5, rows - 12);
+  const start = Math.max(0, Math.min(sel - Math.floor(maxVisible / 2), plugins.length - maxVisible));
+  const visible = plugins.slice(start, start + maxVisible);
+  useEffect15(() => {
+    loadPlugins();
+  }, []);
+  const loadPlugins = async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const { createPluginManager, loadPluginsFromDirectory } = await import("@skillkit/core");
+      const { join: join6 } = await import("path");
+      const manager = createPluginManager(process.cwd());
+      const pluginsDir = join6(process.cwd(), ".skillkit", "plugins");
+      try {
+        const loadedPlugins = await loadPluginsFromDirectory(pluginsDir);
+        for (const plugin of loadedPlugins) {
+          if (!manager.getPlugin(plugin.metadata.name)) {
+            await manager.register(plugin);
+          }
+        }
+      } catch (err) {
+        if (err && typeof err === "object" && "code" in err && err.code !== "ENOENT") {
+          throw err;
+        }
+      }
+      const allPlugins = manager.listPlugins();
+      const pluginInfos = allPlugins.map((p) => {
+        const plugin = manager.getPlugin(p.name);
+        return {
+          name: p.name,
+          version: p.version,
+          description: p.description,
+          author: p.author,
+          enabled: manager.isPluginEnabled(p.name),
+          translators: plugin?.translators?.map((t) => t.agentType),
+          providers: plugin?.providers?.map((pr) => pr.providerName),
+          commands: plugin?.commands?.map((c) => c.name)
+        };
+      });
+      setPlugins(pluginInfos);
+    } catch (e) {
+      setError(e instanceof Error ? e.message : "Failed to load plugins");
+    }
+    setLoading(false);
+  };
+  const togglePlugin = async (pluginName, currentEnabled) => {
+    setLoading(true);
+    setMessage(null);
+    try {
+      const { createPluginManager, loadPluginsFromDirectory } = await import("@skillkit/core");
+      const { join: join6 } = await import("path");
+      const manager = createPluginManager(process.cwd());
+      const pluginsDir = join6(process.cwd(), ".skillkit", "plugins");
+      try {
+        const loadedPlugins = await loadPluginsFromDirectory(pluginsDir);
+        for (const plugin of loadedPlugins) {
+          if (!manager.getPlugin(plugin.metadata.name)) {
+            await manager.register(plugin);
+          }
+        }
+      } catch (err) {
+        if (err && typeof err === "object" && "code" in err && err.code !== "ENOENT") {
+          throw err;
+        }
+      }
+      if (currentEnabled) {
+        manager.disablePlugin(pluginName);
+        setMessage(`Disabled: ${pluginName}`);
+      } else {
+        manager.enablePlugin(pluginName);
+        setMessage(`Enabled: ${pluginName}`);
+      }
+      await loadPlugins();
+    } catch (e) {
+      setError(e instanceof Error ? e.message : "Toggle failed");
+      setLoading(false);
+    }
+  };
+  useInput14((input, key) => {
+    if (loading) return;
+    if (plugins.length === 0 && (key.upArrow || key.downArrow)) return;
+    if (key.upArrow) setSel((i) => Math.max(0, i - 1));
+    else if (key.downArrow) setSel((i) => Math.min(Math.max(0, plugins.length - 1), i + 1));
+    else if (input === "r") loadPlugins();
+    else if (input === "e" && plugins[sel]) {
+      togglePlugin(plugins[sel].name, plugins[sel].enabled);
+    } else if (key.return && plugins[sel]) {
+      togglePlugin(plugins[sel].name, plugins[sel].enabled);
+    }
+  });
+  if (loading) {
+    return /* @__PURE__ */ jsxs16(Box16, { flexDirection: "column", padding: 1, children: [
+      /* @__PURE__ */ jsx16(Text16, { color: colors.primary, bold: true, children: "Plugin Manager" }),
+      /* @__PURE__ */ jsx16(Box16, { marginTop: 1, children: /* @__PURE__ */ jsxs16(Text16, { color: colors.secondaryDim, children: [
+        symbols.spinner[0],
+        " Loading..."
+      ] }) })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs16(Box16, { flexDirection: "column", padding: 1, children: [
+    /* @__PURE__ */ jsx16(Text16, { color: colors.primary, bold: true, children: "Plugin Manager" }),
+    /* @__PURE__ */ jsx16(Text16, { color: colors.secondaryDim, dimColor: true, children: "Manage SkillKit extensions" }),
+    error && /* @__PURE__ */ jsx16(Box16, { marginTop: 1, children: /* @__PURE__ */ jsxs16(Text16, { color: "red", children: [
+      symbols.error,
+      " ",
+      error
+    ] }) }),
+    message && /* @__PURE__ */ jsx16(Box16, { marginTop: 1, children: /* @__PURE__ */ jsxs16(Text16, { color: "green", children: [
+      symbols.success,
+      " ",
+      message
+    ] }) }),
+    /* @__PURE__ */ jsxs16(Box16, { marginTop: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs16(Text16, { color: colors.secondaryDim, bold: true, children: [
+        "Installed Plugins (",
+        plugins.length,
+        ")"
+      ] }),
+      plugins.length === 0 ? /* @__PURE__ */ jsxs16(Box16, { marginTop: 1, flexDirection: "column", children: [
+        /* @__PURE__ */ jsx16(Text16, { color: colors.secondaryDim, dimColor: true, children: "No plugins installed." }),
+        /* @__PURE__ */ jsx16(Text16, { color: colors.secondaryDim, dimColor: true, children: "Use: skillkit plugin install --source <path-or-package>" })
+      ] }) : /* @__PURE__ */ jsx16(Box16, { flexDirection: "column", marginTop: 1, children: visible.map((plugin, i) => {
+        const actualIndex = start + i;
+        const isSelected = actualIndex === sel;
+        const statusColor = plugin.enabled ? "green" : "gray";
+        const statusText = plugin.enabled ? "enabled" : "disabled";
+        return /* @__PURE__ */ jsxs16(Box16, { flexDirection: "column", children: [
+          /* @__PURE__ */ jsxs16(Text16, { children: [
+            isSelected ? symbols.pointer : " ",
+            " ",
+            /* @__PURE__ */ jsx16(Text16, { color: isSelected ? colors.primary : colors.secondaryDim, bold: isSelected, children: plugin.name }),
+            /* @__PURE__ */ jsxs16(Text16, { dimColor: true, children: [
+              " v",
+              plugin.version
+            ] }),
+            /* @__PURE__ */ jsxs16(Text16, { color: statusColor, children: [
+              " [",
+              statusText,
+              "]"
+            ] })
+          ] }),
+          isSelected && /* @__PURE__ */ jsxs16(Box16, { flexDirection: "column", marginLeft: 3, children: [
+            plugin.description && /* @__PURE__ */ jsx16(Text16, { color: colors.secondaryDim, dimColor: true, children: plugin.description }),
+            plugin.author && /* @__PURE__ */ jsxs16(Text16, { dimColor: true, children: [
+              "Author: ",
+              plugin.author
+            ] }),
+            plugin.translators && plugin.translators.length > 0 && /* @__PURE__ */ jsxs16(Text16, { dimColor: true, children: [
+              "Translators: ",
+              plugin.translators.join(", ")
+            ] }),
+            plugin.providers && plugin.providers.length > 0 && /* @__PURE__ */ jsxs16(Text16, { dimColor: true, children: [
+              "Providers: ",
+              plugin.providers.join(", ")
+            ] }),
+            plugin.commands && plugin.commands.length > 0 && /* @__PURE__ */ jsxs16(Text16, { dimColor: true, children: [
+              "Commands: ",
+              plugin.commands.join(", ")
+            ] })
+          ] })
+        ] }, plugin.name);
+      }) })
+    ] }),
+    /* @__PURE__ */ jsx16(Box16, { marginTop: 1, borderStyle: "single", borderColor: colors.borderDim, paddingX: 1, children: /* @__PURE__ */ jsx16(Text16, { dimColor: true, children: "[\u2191\u2193] Navigate  [e/Enter] Toggle Enable/Disable  [r] Refresh" }) })
+  ] });
+}
+
+// src/App.tsx
+import { jsx as jsx17, jsxs as jsxs17 } from "react/jsx-runtime";
 function App() {
-  const [screen, setScreen] = useState12("home");
+  const [screen, setScreen] = useState19("home");
   const { exit } = useApp();
   const { stdout } = useStdout();
   const cols = stdout?.columns || 80;
   const rows = stdout?.rows || 24;
   const showSidebar = cols >= 70;
-  useInput8((input, key) => {
+  const NAV_KEYS = {
+    h: "home",
+    m: "marketplace",
+    b: "browse",
+    w: "workflow",
+    x: "execute",
+    y: "history",
+    r: "recommend",
+    t: "translate",
+    c: "context",
+    e: "memory",
+    i: "installed",
+    s: "sync",
+    a: "team",
+    p: "plugins",
+    ",": "settings"
+  };
+  useInput15((input, key) => {
     if (input === "q") {
       exit();
       return;
@@ -1830,65 +2969,75 @@ function App() {
       setScreen("home");
       return;
     }
-    if (input === "h") setScreen("home");
-    if (input === "b") setScreen("browse");
-    if (input === "l") setScreen("installed");
-    if (input === "s") setScreen("sync");
-    if (input === ",") setScreen("settings");
-    if (input === "r") setScreen("recommend");
-    if (input === "t") setScreen("translate");
-    if (input === "c") setScreen("context");
+    const targetScreen = NAV_KEYS[input];
+    if (targetScreen) {
+      setScreen(targetScreen);
+    }
   });
   const renderScreen = () => {
     switch (screen) {
       case "home":
-        return /* @__PURE__ */ jsx10(Home, { onNavigate: setScreen, cols, rows });
+        return /* @__PURE__ */ jsx17(Home, { onNavigate: setScreen, cols, rows });
       case "browse":
-        return /* @__PURE__ */ jsx10(Browse, { cols, rows });
+        return /* @__PURE__ */ jsx17(Browse, { cols, rows });
       case "installed":
-        return /* @__PURE__ */ jsx10(Installed, { cols, rows });
+        return /* @__PURE__ */ jsx17(Installed, { cols, rows });
       case "sync":
-        return /* @__PURE__ */ jsx10(Sync, { cols, rows });
+        return /* @__PURE__ */ jsx17(Sync, { cols, rows });
       case "settings":
-        return /* @__PURE__ */ jsx10(Settings, { cols, rows });
+        return /* @__PURE__ */ jsx17(Settings, { cols, rows });
       case "recommend":
-        return /* @__PURE__ */ jsx10(Recommend, { cols, rows });
+        return /* @__PURE__ */ jsx17(Recommend, { cols, rows });
       case "translate":
-        return /* @__PURE__ */ jsx10(Translate, { cols, rows });
+        return /* @__PURE__ */ jsx17(Translate, { cols, rows });
       case "context":
-        return /* @__PURE__ */ jsx10(Context, { cols, rows });
+        return /* @__PURE__ */ jsx17(Context, { cols, rows });
+      case "workflow":
+        return /* @__PURE__ */ jsx17(Workflow, { cols, rows });
+      case "execute":
+        return /* @__PURE__ */ jsx17(Execute, { cols, rows });
+      case "history":
+        return /* @__PURE__ */ jsx17(History, { cols, rows });
+      case "marketplace":
+        return /* @__PURE__ */ jsx17(Marketplace, { cols, rows });
+      case "memory":
+        return /* @__PURE__ */ jsx17(Memory, { cols, rows });
+      case "team":
+        return /* @__PURE__ */ jsx17(Team, { cols, rows });
+      case "plugins":
+        return /* @__PURE__ */ jsx17(Plugins, { cols, rows });
     }
   };
   const contentHeight = rows - 2;
-  return /* @__PURE__ */ jsxs10(Box10, { flexDirection: "column", height: rows, children: [
-    /* @__PURE__ */ jsxs10(Box10, { flexDirection: "row", height: contentHeight, children: [
-      showSidebar && /* @__PURE__ */ jsx10(Sidebar, { screen, onNavigate: setScreen }),
-      /* @__PURE__ */ jsx10(Box10, { flexDirection: "column", flexGrow: 1, marginLeft: 1, children: renderScreen() })
+  return /* @__PURE__ */ jsxs17(Box17, { flexDirection: "column", height: rows, children: [
+    /* @__PURE__ */ jsxs17(Box17, { flexDirection: "row", height: contentHeight, children: [
+      showSidebar && /* @__PURE__ */ jsx17(Sidebar, { screen, onNavigate: setScreen }),
+      /* @__PURE__ */ jsx17(Box17, { flexDirection: "column", flexGrow: 1, marginLeft: 1, children: renderScreen() })
     ] }),
-    /* @__PURE__ */ jsx10(Box10, { children: /* @__PURE__ */ jsx10(Text10, { dimColor: true, children: "h Home  b Browse  r Rec  t Trans  c Ctx  l List  s Sync  , Config  q Quit" }) })
+    /* @__PURE__ */ jsx17(Box17, { children: /* @__PURE__ */ jsx17(Text17, { dimColor: true, children: "h Home  m Market  b Browse  i Inst  w Wflow  x Exec  a Team  p Plug  r Rec  t Trans  c Ctx  e Mem  s Sync  , Cfg  q Quit" }) })
   ] });
 }
 
 // src/components/Header.tsx
-import { Box as Box11, Text as Text11 } from "ink";
-import { jsx as jsx11, jsxs as jsxs11 } from "react/jsx-runtime";
+import { Box as Box18, Text as Text18 } from "ink";
+import { jsx as jsx18, jsxs as jsxs18 } from "react/jsx-runtime";
 function Header({ title, subtitle, count }) {
-  return /* @__PURE__ */ jsxs11(Box11, { flexDirection: "column", marginBottom: 1, children: [
-    /* @__PURE__ */ jsxs11(Box11, { justifyContent: "space-between", children: [
-      /* @__PURE__ */ jsx11(Text11, { color: colors.primary, bold: true, children: title.toUpperCase() }),
-      count !== void 0 && /* @__PURE__ */ jsxs11(Text11, { color: colors.secondaryDim, children: [
+  return /* @__PURE__ */ jsxs18(Box18, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsxs18(Box18, { justifyContent: "space-between", children: [
+      /* @__PURE__ */ jsx18(Text18, { color: colors.primary, bold: true, children: title.toUpperCase() }),
+      count !== void 0 && /* @__PURE__ */ jsxs18(Text18, { color: colors.secondaryDim, children: [
         symbols.star,
         " ",
         count
       ] })
     ] }),
-    subtitle && /* @__PURE__ */ jsx11(Text11, { color: colors.secondaryDim, dimColor: true, children: subtitle })
+    subtitle && /* @__PURE__ */ jsx18(Text18, { color: colors.secondaryDim, dimColor: true, children: subtitle })
   ] });
 }
 
 // src/components/SkillList.tsx
-import { Box as Box12, Text as Text12 } from "ink";
-import { jsx as jsx12, jsxs as jsxs12 } from "react/jsx-runtime";
+import { Box as Box19, Text as Text19 } from "ink";
+import { jsx as jsx19, jsxs as jsxs19 } from "react/jsx-runtime";
 function formatInstalls(count) {
   if (count >= 1e3) {
     return `${(count / 1e3).toFixed(1)}K`;
@@ -1904,13 +3053,13 @@ function SkillList({
   maxVisible = 10
 }) {
   if (skills.length === 0) {
-    return /* @__PURE__ */ jsx12(Box12, { children: /* @__PURE__ */ jsx12(Text12, { color: colors.secondaryDim, dimColor: true, children: "No skills found" }) });
+    return /* @__PURE__ */ jsx19(Box19, { children: /* @__PURE__ */ jsx19(Text19, { color: colors.secondaryDim, dimColor: true, children: "No skills found" }) });
   }
   const startIndex = Math.max(0, selectedIndex - Math.floor(maxVisible / 2));
   const visibleSkills = skills.slice(startIndex, startIndex + maxVisible);
   const actualStartIndex = startIndex;
-  return /* @__PURE__ */ jsxs12(Box12, { flexDirection: "column", children: [
-    showRank && /* @__PURE__ */ jsx12(Box12, { marginBottom: 1, children: /* @__PURE__ */ jsxs12(Text12, { color: colors.secondaryDim, children: [
+  return /* @__PURE__ */ jsxs19(Box19, { flexDirection: "column", children: [
+    showRank && /* @__PURE__ */ jsx19(Box19, { marginBottom: 1, children: /* @__PURE__ */ jsxs19(Text19, { color: colors.secondaryDim, children: [
       "  #  SKILL",
       showSource && "                         SOURCE",
       showInstalls && "        INSTALLS"
@@ -1920,9 +3069,9 @@ function SkillList({
       const isSelected = realIndex === selectedIndex;
       const skillName = skill.name.padEnd(28).slice(0, 28);
       const sourceName = skill.source ? skill.source.slice(0, 25) : "";
-      return /* @__PURE__ */ jsxs12(Box12, { children: [
-        /* @__PURE__ */ jsxs12(
-          Text12,
+      return /* @__PURE__ */ jsxs19(Box19, { children: [
+        /* @__PURE__ */ jsxs19(
+          Text19,
           {
             color: isSelected ? colors.primary : colors.secondary,
             bold: isSelected,
@@ -1935,14 +3084,14 @@ function SkillList({
             ]
           }
         ),
-        showSource && /* @__PURE__ */ jsxs12(Text12, { color: colors.secondaryDim, dimColor: !isSelected, children: [
+        showSource && /* @__PURE__ */ jsxs19(Text19, { color: colors.secondaryDim, dimColor: !isSelected, children: [
           " ",
           sourceName
         ] }),
-        showInstalls && skill.installs !== void 0 && /* @__PURE__ */ jsx12(Text12, { color: colors.secondaryDim, children: formatInstalls(skill.installs).padStart(8) })
+        showInstalls && skill.installs !== void 0 && /* @__PURE__ */ jsx19(Text19, { color: colors.secondaryDim, children: formatInstalls(skill.installs).padStart(8) })
       ] }, `${skill.source}-${skill.name}`);
     }),
-    skills.length > maxVisible && /* @__PURE__ */ jsx12(Box12, { marginTop: 1, children: /* @__PURE__ */ jsxs12(Text12, { color: colors.secondaryDim, dimColor: true, children: [
+    skills.length > maxVisible && /* @__PURE__ */ jsx19(Box19, { marginTop: 1, children: /* @__PURE__ */ jsxs19(Text19, { color: colors.secondaryDim, dimColor: true, children: [
       "Showing ",
       startIndex + 1,
       "-",
@@ -1954,11 +3103,11 @@ function SkillList({
 }
 
 // src/components/StatusBar.tsx
-import { Box as Box13, Text as Text13 } from "ink";
-import { jsx as jsx13, jsxs as jsxs13 } from "react/jsx-runtime";
+import { Box as Box20, Text as Text20 } from "ink";
+import { jsx as jsx20, jsxs as jsxs20 } from "react/jsx-runtime";
 function StatusBar({ shortcuts, message }) {
-  return /* @__PURE__ */ jsxs13(
-    Box13,
+  return /* @__PURE__ */ jsxs20(
+    Box20,
     {
       borderStyle: "single",
       borderColor: colors.borderDim,
@@ -1969,11 +3118,11 @@ function StatusBar({ shortcuts, message }) {
       paddingX: 1,
       justifyContent: "space-between",
       children: [
-        /* @__PURE__ */ jsx13(Box13, { gap: 2, children: shortcuts.map((shortcut, idx) => /* @__PURE__ */ jsxs13(Box13, { gap: 1, children: [
-          /* @__PURE__ */ jsx13(Text13, { color: colors.primary, bold: true, children: shortcut.key }),
-          /* @__PURE__ */ jsx13(Text13, { color: colors.secondaryDim, children: shortcut.label })
+        /* @__PURE__ */ jsx20(Box20, { gap: 2, children: shortcuts.map((shortcut, idx) => /* @__PURE__ */ jsxs20(Box20, { gap: 1, children: [
+          /* @__PURE__ */ jsx20(Text20, { color: colors.primary, bold: true, children: shortcut.key }),
+          /* @__PURE__ */ jsx20(Text20, { color: colors.secondaryDim, children: shortcut.label })
         ] }, idx)) }),
-        message && /* @__PURE__ */ jsxs13(Text13, { color: colors.success, children: [
+        message && /* @__PURE__ */ jsxs20(Text20, { color: colors.success, children: [
           symbols.check,
           " ",
           message
@@ -1984,44 +3133,44 @@ function StatusBar({ shortcuts, message }) {
 }
 
 // src/components/SearchInput.tsx
-import { Box as Box14, Text as Text14 } from "ink";
-import TextInput from "ink-text-input";
-import { jsx as jsx14, jsxs as jsxs14 } from "react/jsx-runtime";
+import { Box as Box21, Text as Text21 } from "ink";
+import TextInput2 from "ink-text-input";
+import { jsx as jsx21, jsxs as jsxs21 } from "react/jsx-runtime";
 function SearchInput({
   value,
   onChange,
   placeholder = "Search skills...",
   isFocused = false
 }) {
-  return /* @__PURE__ */ jsxs14(
-    Box14,
+  return /* @__PURE__ */ jsxs21(
+    Box21,
     {
       borderStyle: "single",
       borderColor: isFocused ? colors.primary : colors.borderDim,
       paddingX: 1,
       children: [
-        /* @__PURE__ */ jsx14(Text14, { color: colors.secondaryDim, children: "/ " }),
-        isFocused ? /* @__PURE__ */ jsx14(
-          TextInput,
+        /* @__PURE__ */ jsx21(Text21, { color: colors.secondaryDim, children: "/ " }),
+        isFocused ? /* @__PURE__ */ jsx21(
+          TextInput2,
           {
             value,
             onChange,
             placeholder
           }
-        ) : /* @__PURE__ */ jsx14(Text14, { color: value ? colors.secondary : colors.secondaryDim, children: value || placeholder }),
-        /* @__PURE__ */ jsx14(Box14, { flexGrow: 1 }),
-        /* @__PURE__ */ jsx14(Text14, { color: colors.secondaryDim, children: "/" })
+        ) : /* @__PURE__ */ jsx21(Text21, { color: value ? colors.secondary : colors.secondaryDim, children: value || placeholder }),
+        /* @__PURE__ */ jsx21(Box21, { flexGrow: 1 }),
+        /* @__PURE__ */ jsx21(Text21, { color: colors.secondaryDim, children: "/" })
       ]
     }
   );
 }
 
 // src/hooks/useKeyboard.ts
-import { useState as useState13, useCallback as useCallback3, useEffect as useEffect8 } from "react";
-import { useInput as useInput9, useApp as useApp2 } from "ink";
+import { useState as useState20, useCallback as useCallback3, useEffect as useEffect16 } from "react";
+import { useInput as useInput16, useApp as useApp2 } from "ink";
 function useKeyboard(options = {}) {
   const { exit } = useApp2();
-  useInput9((input, key) => {
+  useInput16((input, key) => {
     if (options.disabled) return;
     if (input === "q" || key.ctrl && input === "c") {
       exit();
@@ -2065,8 +3214,8 @@ function useKeyboard(options = {}) {
   });
 }
 function useListNavigation(listLength, initialIndex = 0) {
-  const [selectedIndex, setSelectedIndex] = useState13(initialIndex);
-  useEffect8(() => {
+  const [selectedIndex, setSelectedIndex] = useState20(initialIndex);
+  useEffect16(() => {
     if (selectedIndex >= listLength && listLength > 0) {
       setSelectedIndex(listLength - 1);
     }
@@ -2083,11 +3232,122 @@ function useListNavigation(listLength, initialIndex = 0) {
   return { selectedIndex, setSelectedIndex, moveUp, moveDown, reset };
 }
 
+// src/hooks/useMemory.ts
+import { useState as useState21, useEffect as useEffect17, useCallback as useCallback4 } from "react";
+import {
+  LearningStore as LearningStore2,
+  ObservationStore as ObservationStore2,
+  getMemoryStatus as getMemoryStatus2,
+  createMemoryInjector as createMemoryInjector2
+} from "@skillkit/core";
+function useMemory() {
+  const [learnings, setLearnings] = useState21([]);
+  const [observations, setObservations] = useState21([]);
+  const [status, setStatus] = useState21(null);
+  const [loading, setLoading] = useState21(true);
+  const [error, setError] = useState21(null);
+  const [isGlobal, setIsGlobal] = useState21(false);
+  const projectPath = process.cwd();
+  const refresh = useCallback4(() => {
+    setLoading(true);
+    setError(null);
+    try {
+      const memStatus = getMemoryStatus2(projectPath);
+      setStatus(memStatus);
+      const learningStore = new LearningStore2(
+        isGlobal ? "global" : "project",
+        isGlobal ? void 0 : projectPath
+      );
+      setLearnings(learningStore.getAll());
+      if (memStatus.hasObservations) {
+        const obsStore = new ObservationStore2(projectPath);
+        setObservations(obsStore.getAll());
+      } else {
+        setObservations([]);
+      }
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Failed to load memory");
+      setLearnings([]);
+      setObservations([]);
+    } finally {
+      setLoading(false);
+    }
+  }, [projectPath, isGlobal]);
+  const search = useCallback4(
+    (query) => {
+      if (!query.trim()) {
+        return [];
+      }
+      try {
+        const injector = createMemoryInjector2(projectPath);
+        const results = injector.search(query, {
+          includeGlobal: true,
+          maxLearnings: 50,
+          minRelevance: 0
+        });
+        return results.map((r) => r.learning);
+      } catch {
+        return [];
+      }
+    },
+    [projectPath]
+  );
+  const deleteLearning = useCallback4(
+    (id) => {
+      try {
+        const store = new LearningStore2(
+          isGlobal ? "global" : "project",
+          isGlobal ? void 0 : projectPath
+        );
+        const result = store.delete(id);
+        if (result) {
+          refresh();
+        }
+        return result;
+      } catch {
+        return false;
+      }
+    },
+    [projectPath, isGlobal, refresh]
+  );
+  const deleteObservation = useCallback4(
+    (id) => {
+      try {
+        const store = new ObservationStore2(projectPath);
+        const result = store.delete(id);
+        if (result) {
+          refresh();
+        }
+        return result;
+      } catch {
+        return false;
+      }
+    },
+    [projectPath, refresh]
+  );
+  useEffect17(() => {
+    refresh();
+  }, [refresh]);
+  return {
+    learnings,
+    observations,
+    status,
+    loading,
+    error,
+    isGlobal,
+    setIsGlobal,
+    refresh,
+    search,
+    deleteLearning,
+    deleteObservation
+  };
+}
+
 // src/index.tsx
-import { jsx as jsx15 } from "react/jsx-runtime";
+import { jsx as jsx22 } from "react/jsx-runtime";
 function startTUI() {
   process.stdout.write("\x1B[2J\x1B[0f");
-  const { waitUntilExit, clear } = render(/* @__PURE__ */ jsx15(App, {}), {
+  const { waitUntilExit, clear } = render(/* @__PURE__ */ jsx22(App, {}), {
     exitOnCtrlC: true
   });
   return waitUntilExit().then(() => {
@@ -2098,9 +3358,14 @@ export {
   App,
   Browse,
   Context,
+  Execute,
   Header,
+  History,
   Home,
   Installed,
+  Marketplace,
+  Memory,
+  Plugins,
   Recommend,
   SearchInput,
   Settings,
@@ -2108,7 +3373,9 @@ export {
   SkillList,
   StatusBar,
   Sync,
+  Team,
   Translate,
+  Workflow,
   colors,
   logo,
   startTUI,
@@ -2116,6 +3383,7 @@ export {
   useKeyboard,
   useListNavigation,
   useMarketplace,
+  useMemory,
   useRecommend,
   useSkills
 };