@skillkit/tui 1.4.0 → 1.6.0

package/dist/index.js

@@ -2,8 +2,8 @@
 import { render } from "ink";
 
 // src/App.tsx
-import { useState as useState17 } from "react";
-import { Box as Box15, Text as Text15, useInput as useInput13, useApp, useStdout } from "ink";
+import { useState as useState21 } from "react";
+import { Box as Box19, Text as Text19, useInput as useInput17, useApp, useStdout } from "ink";
 
 // src/components/Sidebar.tsx
 import { Box, Text } from "ink";
@@ -55,6 +55,12 @@ var NAV = [
   { 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" },
+  // Methodology
+  { id: "methodology", label: "Methodology", key: "o" },
+  { id: "plan", label: "Plans", key: "n" },
   // Tools
   { id: "recommend", label: "Recommend", key: "r" },
   { id: "translate", label: "Translate", key: "t" },
@@ -78,12 +84,22 @@ function Sidebar({ screen }) {
       item.label
     ] }, item.id)),
     /* @__PURE__ */ jsx(Text, { children: " " }),
-    NAV.slice(6, 10).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(10).map((item) => /* @__PURE__ */ jsxs(Text, { inverse: screen === item.id, children: [
+    NAV.slice(8, 10).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(10, 14).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(14).map((item) => /* @__PURE__ */ jsxs(Text, { inverse: screen === item.id, children: [
       screen === item.id ? symbols.bullet : " ",
       item.label
     ] }, item.id)),
@@ -174,14 +190,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" },
@@ -213,6 +231,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([]);
@@ -220,6 +273,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);
@@ -234,12 +289,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];
@@ -251,27 +307,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);
@@ -288,6 +354,8 @@ function useMarketplace() {
     setFetchedRepos(/* @__PURE__ */ new Set());
     setAllSkills([]);
     setFilteredSkills([]);
+    setFailedRepos([]);
+    setError(null);
   }, []);
   useEffect2(() => {
     setFilteredSkills(allSkills);
@@ -302,8 +370,9 @@ function useMarketplace() {
     loading,
     error,
     totalCount: allSkills.length,
-    repos: POPULAR_REPOS,
+    repos,
     currentRepo,
+    failedRepos,
     refresh,
     search,
     fetchRepo,
@@ -317,14 +386,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,
@@ -335,7 +404,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,
@@ -400,11 +469,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 });
@@ -710,44 +779,167 @@ 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 existsSync2, mkdirSync as mkdirSync2, cpSync as cpSync2, rmSync as rmSync2 } from "fs";
-import { join as join3 } from "path";
+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,
@@ -875,7 +1067,7 @@ function useRecommend(projectPath = process.cwd()) {
   const refresh = useCallback2(() => {
     loadRecommendations();
   }, [loadRecommendations]);
-  useEffect5(() => {
+  useEffect6(() => {
     loadRecommendations();
   }, [loadRecommendations]);
   return {
@@ -965,11 +1157,11 @@ function Recommend({ rows = 24 }) {
       const targetAgentType = agentType || await detectAgent2();
       const adapter = getAdapter3(targetAgentType);
       const installDir = getInstallDir(false, targetAgentType);
-      if (!existsSync2(installDir)) {
+      if (!existsSync3(installDir)) {
         mkdirSync2(installDir, { recursive: true });
       }
-      const targetPath = join3(installDir, skillName);
-      if (existsSync2(targetPath)) {
+      const targetPath = join4(installDir, skillName);
+      if (existsSync3(targetPath)) {
         rmSync2(targetPath, { recursive: true, force: true });
       }
       cpSync2(skill.path, targetPath, { recursive: true, dereference: true });
@@ -1172,9 +1364,9 @@ function Recommend({ rows = 24 }) {
 }
 
 // src/screens/Translate.tsx
-import { useState as useState10, useEffect as useEffect6 } from "react";
-import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync2, writeFileSync, mkdirSync as mkdirSync3 } from "fs";
-import { join as join4 } from "path";
+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 {
   translateSkill,
@@ -1192,17 +1384,17 @@ 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 = [];
-      if (existsSync3(installDir)) {
+      if (existsSync4(installDir)) {
         const dirs = readdirSync(installDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
         for (const dir of dirs) {
-          const skillPath = join4(installDir, dir);
-          const skillMdPath = join4(skillPath, "SKILL.md");
-          if (existsSync3(skillMdPath)) {
-            const content = readFileSync2(skillMdPath, "utf-8");
+          const skillPath = join5(installDir, dir);
+          const skillMdPath = join5(skillPath, "SKILL.md");
+          if (existsSync4(skillMdPath)) {
+            const content = readFileSync3(skillMdPath, "utf-8");
             foundSkills.push({
               name: dir,
               path: skillPath,
@@ -1215,7 +1407,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) => ({
@@ -1252,12 +1444,12 @@ function Translate({ rows = 24 }) {
         return;
       }
       const adapter = getAdapter4(selectedAgent.type);
-      const targetDir = adapter?.skillsDir ? join4(process.cwd(), adapter.skillsDir) : join4(process.cwd(), `.${selectedAgent.type}/skills/`);
-      if (!existsSync3(targetDir)) {
+      const targetDir = adapter?.skillsDir ? join5(process.cwd(), adapter.skillsDir) : join5(process.cwd(), `.${selectedAgent.type}/skills/`);
+      if (!existsSync4(targetDir)) {
         mkdirSync3(targetDir, { recursive: true });
       }
       const filename = translationResult.filename || `${selectedSkill.name}.md`;
-      const targetPath = join4(targetDir, filename);
+      const targetPath = join5(targetDir, filename);
       writeFileSync(targetPath, translationResult.content, "utf-8");
       setResult({
         success: true,
@@ -1403,7 +1595,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,
@@ -1423,7 +1615,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 {
@@ -1652,7 +1844,7 @@ function Context({ rows = 24 }) {
 }
 
 // src/screens/Workflow.tsx
-import { useState as useState12, useEffect as useEffect8 } from "react";
+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";
@@ -1665,7 +1857,7 @@ function Workflow({ rows = 24 }) {
   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);
-  useEffect8(() => {
+  useEffect9(() => {
     loadWorkflows();
   }, []);
   const loadWorkflows = () => {
@@ -1745,7 +1937,7 @@ function Workflow({ rows = 24 }) {
 }
 
 // src/screens/Execute.tsx
-import { useState as useState13, useEffect as useEffect9 } from "react";
+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";
@@ -1753,7 +1945,7 @@ function Execute({ rows = 24 }) {
   const [session, setSession] = useState13(null);
   const [loading, setLoading] = useState13(true);
   const maxVisible = Math.max(5, rows - 10);
-  useEffect9(() => {
+  useEffect10(() => {
     loadSession();
     const interval = setInterval(loadSession, 1e3);
     return () => clearInterval(interval);
@@ -1858,7 +2050,7 @@ function Execute({ rows = 24 }) {
 }
 
 // src/screens/History.tsx
-import { useState as useState14, useEffect as useEffect10 } from "react";
+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";
@@ -1870,7 +2062,7 @@ function History({ rows = 24 }) {
   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);
-  useEffect10(() => {
+  useEffect11(() => {
     loadHistory();
   }, []);
   const loadHistory = () => {
@@ -1981,7 +2173,7 @@ function History({ rows = 24 }) {
 }
 
 // src/screens/Marketplace.tsx
-import { useState as useState15, useEffect as useEffect11 } from "react";
+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 = [
@@ -2001,7 +2193,7 @@ function Marketplace({ rows = 24 }) {
   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);
-  useEffect11(() => {
+  useEffect12(() => {
     loadMarketplace();
   }, []);
   const loadMarketplace = async () => {
@@ -2140,7 +2332,7 @@ function Marketplace({ rows = 24 }) {
 }
 
 // src/screens/Memory.tsx
-import { useState as useState16, useEffect as useEffect12 } from "react";
+import { useState as useState16, useEffect as useEffect13 } from "react";
 import { Box as Box14, Text as Text14, useInput as useInput12 } from "ink";
 import {
   ObservationStore,
@@ -2165,7 +2357,7 @@ function Memory({ rows = 24 }) {
   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);
-  useEffect12(() => {
+  useEffect13(() => {
     loadMemory();
   }, [isGlobal]);
   const loadMemory = () => {
@@ -2400,10 +2592,806 @@ function Memory({ rows = 24 }) {
   ] });
 }
 
-// src/App.tsx
+// 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: join7 } = await import("path");
+      const manager = createPluginManager(process.cwd());
+      const pluginsDir = join7(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: join7 } = await import("path");
+      const manager = createPluginManager(process.cwd());
+      const pluginsDir = join7(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/screens/Methodology.tsx
+import { useState as useState19, useEffect as useEffect16, useMemo } from "react";
+import { Box as Box17, Text as Text17, useInput as useInput15 } from "ink";
+import {
+  MethodologyManager
+} from "@skillkit/core";
+import { Fragment as Fragment2, jsx as jsx17, jsxs as jsxs17 } from "react/jsx-runtime";
+function Methodology({ rows = 24 }) {
+  const [packs, setPacks] = useState19([]);
+  const [selectedPack, setSelectedPack] = useState19(null);
+  const [skills, setSkills] = useState19([]);
+  const [loading, setLoading] = useState19(true);
+  const [view, setView] = useState19("packs");
+  const [sel, setSel] = useState19(0);
+  const [error, setError] = useState19(null);
+  const [message, setMessage] = useState19(null);
+  const manager = useMemo(() => new MethodologyManager({
+    projectPath: process.cwd()
+  }), []);
+  const maxVisible = Math.max(5, rows - 10);
+  useEffect16(() => {
+    loadPacks();
+  }, []);
+  const loadPacks = async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const loadedPacks = await manager.listAvailablePacks();
+      setPacks(loadedPacks);
+    } catch (e) {
+      setError(e instanceof Error ? e.message : "Failed to load methodology packs");
+    }
+    setLoading(false);
+  };
+  const loadSkills = async (pack) => {
+    setLoading(true);
+    setError(null);
+    try {
+      const loader = manager.getLoader();
+      const loadedSkills = await loader.loadPackSkills(pack.name);
+      setSkills(loadedSkills);
+      setSelectedPack(pack);
+      setView("skills");
+      setSel(0);
+    } catch (e) {
+      setError(e instanceof Error ? e.message : "Failed to load skills");
+    }
+    setLoading(false);
+  };
+  const installPack = async (pack) => {
+    setLoading(true);
+    setMessage(null);
+    try {
+      await manager.installPack(pack.name);
+      setMessage(`Installed ${pack.name} methodology pack`);
+      await loadPacks();
+    } catch (e) {
+      setError(e instanceof Error ? e.message : "Failed to install pack");
+    }
+    setLoading(false);
+  };
+  const items = view === "packs" ? packs : skills;
+  const start = Math.max(0, Math.min(sel - Math.floor(maxVisible / 2), items.length - maxVisible));
+  const visible = items.slice(start, start + maxVisible);
+  useInput15((input, key) => {
+    if (loading) return;
+    if (key.upArrow) setSel((i) => Math.max(0, i - 1));
+    else if (key.downArrow) setSel((i) => Math.min(items.length - 1, i + 1));
+    else if (input === "r") {
+      if (view === "packs") loadPacks();
+      else if (selectedPack) loadSkills(selectedPack);
+    } else if (key.escape || input === "b") {
+      if (view === "skills") {
+        setView("packs");
+        setSel(0);
+        setSelectedPack(null);
+      }
+    } else if (key.return) {
+      if (view === "packs" && packs[sel]) {
+        loadSkills(packs[sel]);
+      }
+    } else if (input === "i" && view === "packs" && packs[sel]) {
+      installPack(packs[sel]);
+    }
+  });
+  const renderPackItem = (pack, idx) => {
+    const isSel = idx === sel;
+    return /* @__PURE__ */ jsxs17(Box17, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs17(Text17, { inverse: isSel, children: [
+        isSel ? symbols.pointer : " ",
+        " ",
+        pack.name,
+        " ",
+        /* @__PURE__ */ jsxs17(Text17, { dimColor: true, children: [
+          "v",
+          pack.version
+        ] })
+      ] }),
+      isSel && /* @__PURE__ */ jsxs17(Fragment2, { children: [
+        /* @__PURE__ */ jsxs17(Text17, { dimColor: true, children: [
+          "   ",
+          pack.description
+        ] }),
+        /* @__PURE__ */ jsxs17(Text17, { dimColor: true, children: [
+          "   ",
+          pack.skills.length,
+          " skill(s) | Tags: ",
+          pack.tags?.join(", ") || "none"
+        ] })
+      ] })
+    ] }, pack.name);
+  };
+  const renderSkillItem = (skill, idx) => {
+    const isSel = idx === sel;
+    return /* @__PURE__ */ jsxs17(Box17, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs17(Text17, { inverse: isSel, children: [
+        isSel ? symbols.pointer : " ",
+        " ",
+        skill.name
+      ] }),
+      isSel && skill.description && /* @__PURE__ */ jsxs17(Text17, { dimColor: true, children: [
+        "   ",
+        skill.description
+      ] }),
+      isSel && skill.tags && /* @__PURE__ */ jsxs17(Text17, { dimColor: true, children: [
+        "   Tags: ",
+        skill.tags.join(", ")
+      ] })
+    ] }, skill.name);
+  };
+  return /* @__PURE__ */ jsxs17(Box17, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx17(Text17, { bold: true, color: colors.primary, children: view === "packs" ? "METHODOLOGY PACKS" : `${selectedPack?.name.toUpperCase()} SKILLS` }),
+    /* @__PURE__ */ jsx17(Text17, { dimColor: true, children: view === "packs" ? `${packs.length} pack(s) available` : `${skills.length} skill(s) in pack` }),
+    loading && /* @__PURE__ */ jsx17(Text17, { color: "yellow", children: "Loading..." }),
+    error && /* @__PURE__ */ jsxs17(Text17, { color: "red", children: [
+      symbols.error,
+      " ",
+      error
+    ] }),
+    message && /* @__PURE__ */ jsxs17(Text17, { color: "green", children: [
+      symbols.success,
+      " ",
+      message
+    ] }),
+    !loading && items.length === 0 && /* @__PURE__ */ jsx17(Box17, { marginTop: 1, children: /* @__PURE__ */ jsxs17(Text17, { dimColor: true, children: [
+      "No ",
+      view === "packs" ? "methodology packs" : "skills",
+      " found."
+    ] }) }),
+    !loading && items.length > 0 && /* @__PURE__ */ jsxs17(Box17, { marginTop: 1, flexDirection: "column", children: [
+      start > 0 && /* @__PURE__ */ jsxs17(Text17, { dimColor: true, children: [
+        "  ",
+        symbols.arrowUp,
+        " ",
+        start,
+        " more"
+      ] }),
+      view === "packs" ? visible.map((pack, i) => renderPackItem(pack, start + i)) : visible.map((skill, i) => renderSkillItem(skill, start + i)),
+      start + maxVisible < items.length && /* @__PURE__ */ jsxs17(Text17, { dimColor: true, children: [
+        "  ",
+        symbols.arrowDown,
+        " ",
+        items.length - start - maxVisible,
+        " more"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx17(Box17, { marginTop: 1, flexDirection: "column", children: view === "packs" ? /* @__PURE__ */ jsx17(Text17, { dimColor: true, children: "Enter=view skills  i=install  r=refresh  q=quit" }) : /* @__PURE__ */ jsx17(Text17, { dimColor: true, children: "b/Esc=back  r=refresh  q=quit" }) })
+  ] });
+}
+
+// src/screens/Plan.tsx
+import { useState as useState20, useEffect as useEffect17, useMemo as useMemo2 } from "react";
+import { Box as Box18, Text as Text18, useInput as useInput16 } from "ink";
+import {
+  PlanParser,
+  PlanValidator,
+  PlanExecutor
+} from "@skillkit/core";
+import * as fs from "fs";
+import * as path from "path";
+import { Fragment as Fragment3, jsx as jsx18, jsxs as jsxs18 } from "react/jsx-runtime";
+function Plan({ rows = 24 }) {
+  const [planFiles, setPlanFiles] = useState20([]);
+  const [selectedPlan, setSelectedPlan] = useState20(null);
+  const [selectedTask, setSelectedTask] = useState20(null);
+  const [loading, setLoading] = useState20(true);
+  const [view, setView] = useState20("plans");
+  const [sel, setSel] = useState20(0);
+  const [error, setError] = useState20(null);
+  const [executing, setExecuting] = useState20(false);
+  const [message, setMessage] = useState20(null);
+  const parser = useMemo2(() => new PlanParser(), []);
+  const validator = useMemo2(() => new PlanValidator(), []);
+  const maxVisible = Math.max(5, rows - 10);
+  useEffect17(() => {
+    loadPlans();
+  }, []);
+  const loadPlans = async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const cwd = process.cwd();
+      const files = [];
+      const searchPaths = [
+        cwd,
+        path.join(cwd, "plans"),
+        path.join(cwd, ".skillkit", "plans")
+      ];
+      for (const searchPath of searchPaths) {
+        if (fs.existsSync(searchPath)) {
+          const entries = fs.readdirSync(searchPath, { withFileTypes: true });
+          for (const entry of entries) {
+            if (entry.isFile() && (entry.name.endsWith(".plan.md") || entry.name.endsWith("-plan.md"))) {
+              const filePath = path.join(searchPath, entry.name);
+              const content = fs.readFileSync(filePath, "utf-8");
+              try {
+                const plan = parser.parse(content);
+                const validation = validator.validate(plan);
+                const errorIssue = validation.issues.find((i) => i.type === "error");
+                files.push({
+                  name: entry.name,
+                  path: filePath,
+                  plan,
+                  valid: validation.valid,
+                  error: errorIssue?.message
+                });
+              } catch {
+                files.push({
+                  name: entry.name,
+                  path: filePath,
+                  valid: false,
+                  error: "Failed to parse plan"
+                });
+              }
+            }
+          }
+        }
+      }
+      setPlanFiles(files);
+    } catch (e) {
+      setError(e instanceof Error ? e.message : "Failed to load plans");
+    }
+    setLoading(false);
+  };
+  const selectPlan = (planFile) => {
+    if (planFile.plan) {
+      setSelectedPlan(planFile);
+      setView("tasks");
+      setSel(0);
+    }
+  };
+  const selectTask = (task) => {
+    setSelectedTask(task);
+    setView("steps");
+    setSel(0);
+  };
+  const executePlan = async (planFile) => {
+    if (!planFile.plan) return;
+    setExecuting(true);
+    setMessage(null);
+    try {
+      const executor = new PlanExecutor();
+      await executor.execute(planFile.plan, { dryRun: true });
+      setMessage(`Executed plan: ${planFile.plan.name} (dry run)`);
+    } catch (e) {
+      setError(e instanceof Error ? e.message : "Failed to execute plan");
+    }
+    setExecuting(false);
+  };
+  const getItems = () => {
+    if (view === "plans") return planFiles;
+    if (view === "tasks" && selectedPlan?.plan) return selectedPlan.plan.tasks;
+    if (view === "steps" && selectedTask) return selectedTask.steps;
+    return [];
+  };
+  const items = getItems();
+  const start = Math.max(0, Math.min(sel - Math.floor(maxVisible / 2), items.length - maxVisible));
+  const visible = items.slice(start, start + maxVisible);
+  useInput16((input, key) => {
+    if (loading || executing) return;
+    if (key.upArrow) setSel((i) => Math.max(0, i - 1));
+    else if (key.downArrow) setSel((i) => Math.min(items.length - 1, i + 1));
+    else if (input === "r") loadPlans();
+    else if (key.escape || input === "b") {
+      if (view === "steps") {
+        setView("tasks");
+        setSelectedTask(null);
+        setSel(0);
+      } else if (view === "tasks") {
+        setView("plans");
+        setSelectedPlan(null);
+        setSel(0);
+      }
+    } else if (key.return) {
+      if (view === "plans" && planFiles[sel]) {
+        selectPlan(planFiles[sel]);
+      } else if (view === "tasks" && selectedPlan?.plan?.tasks[sel]) {
+        selectTask(selectedPlan.plan.tasks[sel]);
+      }
+    } else if (input === "x" && view === "plans" && planFiles[sel]?.plan) {
+      executePlan(planFiles[sel]);
+    }
+  });
+  const renderPlanItem = (planFile, idx) => {
+    const isSel = idx === sel;
+    const statusIcon = planFile.valid ? symbols.success : symbols.error;
+    const statusColor = planFile.valid ? "green" : "red";
+    return /* @__PURE__ */ jsxs18(Box18, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs18(Text18, { inverse: isSel, children: [
+        isSel ? symbols.pointer : " ",
+        " ",
+        /* @__PURE__ */ jsx18(Text18, { color: statusColor, children: statusIcon }),
+        " ",
+        planFile.name
+      ] }),
+      isSel && planFile.plan && /* @__PURE__ */ jsxs18(Fragment3, { children: [
+        /* @__PURE__ */ jsxs18(Text18, { dimColor: true, children: [
+          "   ",
+          planFile.plan.goal
+        ] }),
+        /* @__PURE__ */ jsxs18(Text18, { dimColor: true, children: [
+          "   ",
+          planFile.plan.tasks.length,
+          " task(s) | ",
+          planFile.plan.techStack?.join(", ") || "No stack"
+        ] })
+      ] }),
+      isSel && planFile.error && /* @__PURE__ */ jsxs18(Text18, { color: "red", children: [
+        "   ",
+        planFile.error
+      ] })
+    ] }, planFile.path);
+  };
+  const renderTaskItem = (task, idx) => {
+    const isSel = idx === sel;
+    return /* @__PURE__ */ jsxs18(Box18, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs18(Text18, { inverse: isSel, children: [
+        isSel ? symbols.pointer : " ",
+        " [",
+        task.id,
+        "] ",
+        task.name
+      ] }),
+      isSel && /* @__PURE__ */ jsxs18(Fragment3, { children: [
+        /* @__PURE__ */ jsxs18(Text18, { dimColor: true, children: [
+          "   ",
+          task.steps.length,
+          " step(s)"
+        ] }),
+        task.files?.create && /* @__PURE__ */ jsxs18(Text18, { dimColor: true, children: [
+          "   Create: ",
+          task.files.create.join(", ")
+        ] }),
+        task.files?.modify && /* @__PURE__ */ jsxs18(Text18, { dimColor: true, children: [
+          "   Modify: ",
+          task.files.modify.join(", ")
+        ] }),
+        task.files?.test && /* @__PURE__ */ jsxs18(Text18, { dimColor: true, children: [
+          "   Test: ",
+          task.files.test.join(", ")
+        ] })
+      ] })
+    ] }, task.id);
+  };
+  const renderStepItem = (step, idx) => {
+    const isSel = idx === sel;
+    const typeColors = {
+      test: "yellow",
+      verify: "cyan",
+      implement: "green",
+      commit: "magenta"
+    };
+    return /* @__PURE__ */ jsxs18(Box18, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs18(Text18, { inverse: isSel, children: [
+        isSel ? symbols.pointer : " ",
+        " ",
+        /* @__PURE__ */ jsxs18(Text18, { color: typeColors[step.type] || "white", children: [
+          "[",
+          step.type,
+          "]"
+        ] }),
+        " Step ",
+        step.number
+      ] }),
+      isSel && /* @__PURE__ */ jsxs18(Text18, { dimColor: true, children: [
+        "   ",
+        step.description
+      ] })
+    ] }, step.number);
+  };
+  const getTitle = () => {
+    if (view === "plans") return "PLANS";
+    if (view === "tasks") return `TASKS: ${selectedPlan?.plan?.name || ""}`;
+    if (view === "steps") return `STEPS: Task ${selectedTask?.id}`;
+    return "PLANS";
+  };
+  return /* @__PURE__ */ jsxs18(Box18, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx18(Text18, { bold: true, color: colors.primary, children: getTitle() }),
+    /* @__PURE__ */ jsxs18(Text18, { dimColor: true, children: [
+      view === "plans" && `${planFiles.length} plan(s) found`,
+      view === "tasks" && selectedPlan?.plan && `${selectedPlan.plan.tasks.length} task(s)`,
+      view === "steps" && selectedTask && `${selectedTask.steps.length} step(s)`
+    ] }),
+    loading && /* @__PURE__ */ jsx18(Text18, { color: "yellow", children: "Loading plans..." }),
+    executing && /* @__PURE__ */ jsx18(Text18, { color: "yellow", children: "Executing plan..." }),
+    error && /* @__PURE__ */ jsxs18(Text18, { color: "red", children: [
+      symbols.error,
+      " ",
+      error
+    ] }),
+    message && /* @__PURE__ */ jsxs18(Text18, { color: "green", children: [
+      symbols.success,
+      " ",
+      message
+    ] }),
+    !loading && !executing && items.length === 0 && /* @__PURE__ */ jsxs18(Box18, { marginTop: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs18(Text18, { dimColor: true, children: [
+        "No ",
+        view,
+        " found."
+      ] }),
+      view === "plans" && /* @__PURE__ */ jsx18(Text18, { dimColor: true, children: "Create a plan file: *.plan.md or *-plan.md" })
+    ] }),
+    !loading && !executing && items.length > 0 && /* @__PURE__ */ jsxs18(Box18, { marginTop: 1, flexDirection: "column", children: [
+      start > 0 && /* @__PURE__ */ jsxs18(Text18, { dimColor: true, children: [
+        "  \u2191 ",
+        start,
+        " more"
+      ] }),
+      view === "plans" && visible.map((pf, i) => renderPlanItem(pf, start + i)),
+      view === "tasks" && visible.map((t, i) => renderTaskItem(t, start + i)),
+      view === "steps" && visible.map((s, i) => renderStepItem(s, start + i)),
+      start + maxVisible < items.length && /* @__PURE__ */ jsxs18(Text18, { dimColor: true, children: [
+        "  \u2193 ",
+        items.length - start - maxVisible,
+        " more"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs18(Box18, { marginTop: 1, children: [
+      view === "plans" && /* @__PURE__ */ jsx18(Text18, { dimColor: true, children: "Enter=view tasks  x=execute (dry-run)  r=refresh  q=quit" }),
+      view === "tasks" && /* @__PURE__ */ jsx18(Text18, { dimColor: true, children: "Enter=view steps  b/Esc=back  q=quit" }),
+      view === "steps" && /* @__PURE__ */ jsx18(Text18, { dimColor: true, children: "b/Esc=back  q=quit" })
+    ] })
+  ] });
+}
+
+// src/App.tsx
+import { jsx as jsx19, jsxs as jsxs19 } from "react/jsx-runtime";
 function App() {
-  const [screen, setScreen] = useState17("home");
+  const [screen, setScreen] = useState21("home");
   const { exit } = useApp();
   const { stdout } = useStdout();
   const cols = stdout?.columns || 80;
@@ -2422,9 +3410,13 @@ function App() {
     e: "memory",
     i: "installed",
     s: "sync",
+    a: "team",
+    p: "plugins",
+    o: "methodology",
+    n: "plan",
     ",": "settings"
   };
-  useInput13((input, key) => {
+  useInput17((input, key) => {
     if (input === "q") {
       exit();
       return;
@@ -2441,63 +3433,71 @@ function App() {
   const renderScreen = () => {
     switch (screen) {
       case "home":
-        return /* @__PURE__ */ jsx15(Home, { onNavigate: setScreen, cols, rows });
+        return /* @__PURE__ */ jsx19(Home, { onNavigate: setScreen, cols, rows });
       case "browse":
-        return /* @__PURE__ */ jsx15(Browse, { cols, rows });
+        return /* @__PURE__ */ jsx19(Browse, { cols, rows });
       case "installed":
-        return /* @__PURE__ */ jsx15(Installed, { cols, rows });
+        return /* @__PURE__ */ jsx19(Installed, { cols, rows });
       case "sync":
-        return /* @__PURE__ */ jsx15(Sync, { cols, rows });
+        return /* @__PURE__ */ jsx19(Sync, { cols, rows });
       case "settings":
-        return /* @__PURE__ */ jsx15(Settings, { cols, rows });
+        return /* @__PURE__ */ jsx19(Settings, { cols, rows });
       case "recommend":
-        return /* @__PURE__ */ jsx15(Recommend, { cols, rows });
+        return /* @__PURE__ */ jsx19(Recommend, { cols, rows });
       case "translate":
-        return /* @__PURE__ */ jsx15(Translate, { cols, rows });
+        return /* @__PURE__ */ jsx19(Translate, { cols, rows });
       case "context":
-        return /* @__PURE__ */ jsx15(Context, { cols, rows });
+        return /* @__PURE__ */ jsx19(Context, { cols, rows });
       case "workflow":
-        return /* @__PURE__ */ jsx15(Workflow, { cols, rows });
+        return /* @__PURE__ */ jsx19(Workflow, { cols, rows });
       case "execute":
-        return /* @__PURE__ */ jsx15(Execute, { cols, rows });
+        return /* @__PURE__ */ jsx19(Execute, { cols, rows });
       case "history":
-        return /* @__PURE__ */ jsx15(History, { cols, rows });
+        return /* @__PURE__ */ jsx19(History, { cols, rows });
       case "marketplace":
-        return /* @__PURE__ */ jsx15(Marketplace, { cols, rows });
+        return /* @__PURE__ */ jsx19(Marketplace, { cols, rows });
       case "memory":
-        return /* @__PURE__ */ jsx15(Memory, { cols, rows });
+        return /* @__PURE__ */ jsx19(Memory, { cols, rows });
+      case "team":
+        return /* @__PURE__ */ jsx19(Team, { cols, rows });
+      case "plugins":
+        return /* @__PURE__ */ jsx19(Plugins, { cols, rows });
+      case "methodology":
+        return /* @__PURE__ */ jsx19(Methodology, { cols, rows });
+      case "plan":
+        return /* @__PURE__ */ jsx19(Plan, { cols, rows });
     }
   };
   const contentHeight = rows - 2;
-  return /* @__PURE__ */ jsxs15(Box15, { flexDirection: "column", height: rows, children: [
-    /* @__PURE__ */ jsxs15(Box15, { flexDirection: "row", height: contentHeight, children: [
-      showSidebar && /* @__PURE__ */ jsx15(Sidebar, { screen, onNavigate: setScreen }),
-      /* @__PURE__ */ jsx15(Box15, { flexDirection: "column", flexGrow: 1, marginLeft: 1, children: renderScreen() })
+  return /* @__PURE__ */ jsxs19(Box19, { flexDirection: "column", height: rows, children: [
+    /* @__PURE__ */ jsxs19(Box19, { flexDirection: "row", height: contentHeight, children: [
+      showSidebar && /* @__PURE__ */ jsx19(Sidebar, { screen, onNavigate: setScreen }),
+      /* @__PURE__ */ jsx19(Box19, { flexDirection: "column", flexGrow: 1, marginLeft: 1, children: renderScreen() })
     ] }),
-    /* @__PURE__ */ jsx15(Box15, { children: /* @__PURE__ */ jsx15(Text15, { dimColor: true, children: "h Home  m Market  b Browse  i Inst  w Wflow  x Exec  y Hist  r Rec  t Trans  c Ctx  e Mem  s Sync  , Cfg  q Quit" }) })
+    /* @__PURE__ */ jsx19(Box19, { children: /* @__PURE__ */ jsx19(Text19, { dimColor: true, children: "h Home  m Market  b Browse  w Wflow  x Exec  a Team  p Plug  o Meth  n Plan  r Rec  t Trans  c Ctx  e Mem  i Inst  s Sync  q Quit" }) })
   ] });
 }
 
 // src/components/Header.tsx
-import { Box as Box16, Text as Text16 } from "ink";
-import { jsx as jsx16, jsxs as jsxs16 } 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 Header({ title, subtitle, count }) {
-  return /* @__PURE__ */ jsxs16(Box16, { flexDirection: "column", marginBottom: 1, children: [
-    /* @__PURE__ */ jsxs16(Box16, { justifyContent: "space-between", children: [
-      /* @__PURE__ */ jsx16(Text16, { color: colors.primary, bold: true, children: title.toUpperCase() }),
-      count !== void 0 && /* @__PURE__ */ jsxs16(Text16, { color: colors.secondaryDim, children: [
+  return /* @__PURE__ */ jsxs20(Box20, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsxs20(Box20, { justifyContent: "space-between", children: [
+      /* @__PURE__ */ jsx20(Text20, { color: colors.primary, bold: true, children: title.toUpperCase() }),
+      count !== void 0 && /* @__PURE__ */ jsxs20(Text20, { color: colors.secondaryDim, children: [
         symbols.star,
         " ",
         count
       ] })
     ] }),
-    subtitle && /* @__PURE__ */ jsx16(Text16, { color: colors.secondaryDim, dimColor: true, children: subtitle })
+    subtitle && /* @__PURE__ */ jsx20(Text20, { color: colors.secondaryDim, dimColor: true, children: subtitle })
   ] });
 }
 
 // src/components/SkillList.tsx
-import { Box as Box17, Text as Text17 } from "ink";
-import { jsx as jsx17, jsxs as jsxs17 } from "react/jsx-runtime";
+import { Box as Box21, Text as Text21 } from "ink";
+import { jsx as jsx21, jsxs as jsxs21 } from "react/jsx-runtime";
 function formatInstalls(count) {
   if (count >= 1e3) {
     return `${(count / 1e3).toFixed(1)}K`;
@@ -2513,13 +3513,13 @@ function SkillList({
   maxVisible = 10
 }) {
   if (skills.length === 0) {
-    return /* @__PURE__ */ jsx17(Box17, { children: /* @__PURE__ */ jsx17(Text17, { color: colors.secondaryDim, dimColor: true, children: "No skills found" }) });
+    return /* @__PURE__ */ jsx21(Box21, { children: /* @__PURE__ */ jsx21(Text21, { 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__ */ jsxs17(Box17, { flexDirection: "column", children: [
-    showRank && /* @__PURE__ */ jsx17(Box17, { marginBottom: 1, children: /* @__PURE__ */ jsxs17(Text17, { color: colors.secondaryDim, children: [
+  return /* @__PURE__ */ jsxs21(Box21, { flexDirection: "column", children: [
+    showRank && /* @__PURE__ */ jsx21(Box21, { marginBottom: 1, children: /* @__PURE__ */ jsxs21(Text21, { color: colors.secondaryDim, children: [
       "  #  SKILL",
       showSource && "                         SOURCE",
       showInstalls && "        INSTALLS"
@@ -2529,9 +3529,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__ */ jsxs17(Box17, { children: [
-        /* @__PURE__ */ jsxs17(
-          Text17,
+      return /* @__PURE__ */ jsxs21(Box21, { children: [
+        /* @__PURE__ */ jsxs21(
+          Text21,
           {
             color: isSelected ? colors.primary : colors.secondary,
             bold: isSelected,
@@ -2544,14 +3544,14 @@ function SkillList({
             ]
           }
         ),
-        showSource && /* @__PURE__ */ jsxs17(Text17, { color: colors.secondaryDim, dimColor: !isSelected, children: [
+        showSource && /* @__PURE__ */ jsxs21(Text21, { color: colors.secondaryDim, dimColor: !isSelected, children: [
           " ",
           sourceName
         ] }),
-        showInstalls && skill.installs !== void 0 && /* @__PURE__ */ jsx17(Text17, { color: colors.secondaryDim, children: formatInstalls(skill.installs).padStart(8) })
+        showInstalls && skill.installs !== void 0 && /* @__PURE__ */ jsx21(Text21, { color: colors.secondaryDim, children: formatInstalls(skill.installs).padStart(8) })
       ] }, `${skill.source}-${skill.name}`);
     }),
-    skills.length > maxVisible && /* @__PURE__ */ jsx17(Box17, { marginTop: 1, children: /* @__PURE__ */ jsxs17(Text17, { color: colors.secondaryDim, dimColor: true, children: [
+    skills.length > maxVisible && /* @__PURE__ */ jsx21(Box21, { marginTop: 1, children: /* @__PURE__ */ jsxs21(Text21, { color: colors.secondaryDim, dimColor: true, children: [
       "Showing ",
       startIndex + 1,
       "-",
@@ -2563,11 +3563,11 @@ function SkillList({
 }
 
 // src/components/StatusBar.tsx
-import { Box as Box18, Text as Text18 } from "ink";
-import { jsx as jsx18, jsxs as jsxs18 } from "react/jsx-runtime";
+import { Box as Box22, Text as Text22 } from "ink";
+import { jsx as jsx22, jsxs as jsxs22 } from "react/jsx-runtime";
 function StatusBar({ shortcuts, message }) {
-  return /* @__PURE__ */ jsxs18(
-    Box18,
+  return /* @__PURE__ */ jsxs22(
+    Box22,
     {
       borderStyle: "single",
       borderColor: colors.borderDim,
@@ -2578,11 +3578,11 @@ function StatusBar({ shortcuts, message }) {
       paddingX: 1,
       justifyContent: "space-between",
       children: [
-        /* @__PURE__ */ jsx18(Box18, { gap: 2, children: shortcuts.map((shortcut, idx) => /* @__PURE__ */ jsxs18(Box18, { gap: 1, children: [
-          /* @__PURE__ */ jsx18(Text18, { color: colors.primary, bold: true, children: shortcut.key }),
-          /* @__PURE__ */ jsx18(Text18, { color: colors.secondaryDim, children: shortcut.label })
+        /* @__PURE__ */ jsx22(Box22, { gap: 2, children: shortcuts.map((shortcut, idx) => /* @__PURE__ */ jsxs22(Box22, { gap: 1, children: [
+          /* @__PURE__ */ jsx22(Text22, { color: colors.primary, bold: true, children: shortcut.key }),
+          /* @__PURE__ */ jsx22(Text22, { color: colors.secondaryDim, children: shortcut.label })
         ] }, idx)) }),
-        message && /* @__PURE__ */ jsxs18(Text18, { color: colors.success, children: [
+        message && /* @__PURE__ */ jsxs22(Text22, { color: colors.success, children: [
           symbols.check,
           " ",
           message
@@ -2593,44 +3593,44 @@ function StatusBar({ shortcuts, message }) {
 }
 
 // src/components/SearchInput.tsx
-import { Box as Box19, Text as Text19 } from "ink";
-import TextInput from "ink-text-input";
-import { jsx as jsx19, jsxs as jsxs19 } from "react/jsx-runtime";
+import { Box as Box23, Text as Text23 } from "ink";
+import TextInput2 from "ink-text-input";
+import { jsx as jsx23, jsxs as jsxs23 } from "react/jsx-runtime";
 function SearchInput({
   value,
   onChange,
   placeholder = "Search skills...",
   isFocused = false
 }) {
-  return /* @__PURE__ */ jsxs19(
-    Box19,
+  return /* @__PURE__ */ jsxs23(
+    Box23,
     {
       borderStyle: "single",
       borderColor: isFocused ? colors.primary : colors.borderDim,
       paddingX: 1,
       children: [
-        /* @__PURE__ */ jsx19(Text19, { color: colors.secondaryDim, children: "/ " }),
-        isFocused ? /* @__PURE__ */ jsx19(
-          TextInput,
+        /* @__PURE__ */ jsx23(Text23, { color: colors.secondaryDim, children: "/ " }),
+        isFocused ? /* @__PURE__ */ jsx23(
+          TextInput2,
           {
             value,
             onChange,
             placeholder
           }
-        ) : /* @__PURE__ */ jsx19(Text19, { color: value ? colors.secondary : colors.secondaryDim, children: value || placeholder }),
-        /* @__PURE__ */ jsx19(Box19, { flexGrow: 1 }),
-        /* @__PURE__ */ jsx19(Text19, { color: colors.secondaryDim, children: "/" })
+        ) : /* @__PURE__ */ jsx23(Text23, { color: value ? colors.secondary : colors.secondaryDim, children: value || placeholder }),
+        /* @__PURE__ */ jsx23(Box23, { flexGrow: 1 }),
+        /* @__PURE__ */ jsx23(Text23, { color: colors.secondaryDim, children: "/" })
       ]
     }
   );
 }
 
 // src/hooks/useKeyboard.ts
-import { useState as useState18, useCallback as useCallback3, useEffect as useEffect13 } from "react";
-import { useInput as useInput14, useApp as useApp2 } from "ink";
+import { useState as useState22, useCallback as useCallback3, useEffect as useEffect18 } from "react";
+import { useInput as useInput18, useApp as useApp2 } from "ink";
 function useKeyboard(options = {}) {
   const { exit } = useApp2();
-  useInput14((input, key) => {
+  useInput18((input, key) => {
     if (options.disabled) return;
     if (input === "q" || key.ctrl && input === "c") {
       exit();
@@ -2674,8 +3674,8 @@ function useKeyboard(options = {}) {
   });
 }
 function useListNavigation(listLength, initialIndex = 0) {
-  const [selectedIndex, setSelectedIndex] = useState18(initialIndex);
-  useEffect13(() => {
+  const [selectedIndex, setSelectedIndex] = useState22(initialIndex);
+  useEffect18(() => {
     if (selectedIndex >= listLength && listLength > 0) {
       setSelectedIndex(listLength - 1);
     }
@@ -2693,7 +3693,7 @@ function useListNavigation(listLength, initialIndex = 0) {
 }
 
 // src/hooks/useMemory.ts
-import { useState as useState19, useEffect as useEffect14, useCallback as useCallback4 } from "react";
+import { useState as useState23, useEffect as useEffect19, useCallback as useCallback4 } from "react";
 import {
   LearningStore as LearningStore2,
   ObservationStore as ObservationStore2,
@@ -2701,12 +3701,12 @@ import {
   createMemoryInjector as createMemoryInjector2
 } from "@skillkit/core";
 function useMemory() {
-  const [learnings, setLearnings] = useState19([]);
-  const [observations, setObservations] = useState19([]);
-  const [status, setStatus] = useState19(null);
-  const [loading, setLoading] = useState19(true);
-  const [error, setError] = useState19(null);
-  const [isGlobal, setIsGlobal] = useState19(false);
+  const [learnings, setLearnings] = useState23([]);
+  const [observations, setObservations] = useState23([]);
+  const [status, setStatus] = useState23(null);
+  const [loading, setLoading] = useState23(true);
+  const [error, setError] = useState23(null);
+  const [isGlobal, setIsGlobal] = useState23(false);
   const projectPath = process.cwd();
   const refresh = useCallback4(() => {
     setLoading(true);
@@ -2785,7 +3785,7 @@ function useMemory() {
     },
     [projectPath, refresh]
   );
-  useEffect14(() => {
+  useEffect19(() => {
     refresh();
   }, [refresh]);
   return {
@@ -2804,10 +3804,10 @@ function useMemory() {
 }
 
 // src/index.tsx
-import { jsx as jsx20 } from "react/jsx-runtime";
+import { jsx as jsx24 } from "react/jsx-runtime";
 function startTUI() {
   process.stdout.write("\x1B[2J\x1B[0f");
-  const { waitUntilExit, clear } = render(/* @__PURE__ */ jsx20(App, {}), {
+  const { waitUntilExit, clear } = render(/* @__PURE__ */ jsx24(App, {}), {
     exitOnCtrlC: true
   });
   return waitUntilExit().then(() => {
@@ -2825,6 +3825,9 @@ export {
   Installed,
   Marketplace,
   Memory,
+  Methodology,
+  Plan,
+  Plugins,
   Recommend,
   SearchInput,
   Settings,
@@ -2832,6 +3835,7 @@ export {
   SkillList,
   StatusBar,
   Sync,
+  Team,
   Translate,
   Workflow,
   colors,