@skillkit/tui 1.3.0 → 1.4.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 useState17 } from "react";
+import { Box as Box15, Text as Text15, useInput as useInput13, 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,23 @@ 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" },
+  // 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 +73,17 @@ 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, 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).map((item) => /* @__PURE__ */ jsxs(Text, { inverse: screen === item.id, children: [
       screen === item.id ? symbols.bullet : " ",
       item.label
     ] }, item.id)),
@@ -722,174 +742,21 @@ function Settings({}) {
 
 // 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 { join as join4 } from "path";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, cpSync as cpSync2, rmSync as rmSync2 } from "fs";
+import { join as join3 } 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 {
   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 +767,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 +837,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()) {
@@ -1126,11 +965,11 @@ function Recommend({ rows = 24 }) {
       const targetAgentType = agentType || await detectAgent2();
       const adapter = getAdapter3(targetAgentType);
       const installDir = getInstallDir(false, targetAgentType);
-      if (!existsSync3(installDir)) {
-        mkdirSync3(installDir, { recursive: true });
+      if (!existsSync2(installDir)) {
+        mkdirSync2(installDir, { recursive: true });
       }
-      const targetPath = join4(installDir, skillName);
-      if (existsSync3(targetPath)) {
+      const targetPath = join3(installDir, skillName);
+      if (existsSync2(targetPath)) {
         rmSync2(targetPath, { recursive: true, force: true });
       }
       cpSync2(skill.path, targetPath, { recursive: true, dereference: true });
@@ -1334,8 +1173,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 { join as join5 } from "path";
+import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync2, writeFileSync, mkdirSync as mkdirSync3 } from "fs";
+import { join as join4 } from "path";
 import { Box as Box8, Text as Text8, useInput as useInput6 } from "ink";
 import {
   translateSkill,
@@ -1357,13 +1196,13 @@ function Translate({ rows = 24 }) {
     const loadSkills = () => {
       const installDir = getInstallDir(false);
       const foundSkills = [];
-      if (existsSync4(installDir)) {
+      if (existsSync3(installDir)) {
         const dirs = readdirSync(installDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
         for (const dir of dirs) {
-          const skillPath = join5(installDir, dir);
-          const skillMdPath = join5(skillPath, "SKILL.md");
-          if (existsSync4(skillMdPath)) {
-            const content = readFileSync3(skillMdPath, "utf-8");
+          const skillPath = join4(installDir, dir);
+          const skillMdPath = join4(skillPath, "SKILL.md");
+          if (existsSync3(skillMdPath)) {
+            const content = readFileSync2(skillMdPath, "utf-8");
             foundSkills.push({
               name: dir,
               path: skillPath,
@@ -1413,13 +1252,13 @@ function Translate({ rows = 24 }) {
         return;
       }
       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 });
+      const targetDir = adapter?.skillsDir ? join4(process.cwd(), adapter.skillsDir) : join4(process.cwd(), `.${selectedAgent.type}/skills/`);
+      if (!existsSync3(targetDir)) {
+        mkdirSync3(targetDir, { recursive: true });
       }
       const filename = translationResult.filename || `${selectedSkill.name}.md`;
-      const targetPath = join5(targetDir, filename);
-      writeFileSync2(targetPath, translationResult.content, "utf-8");
+      const targetPath = join4(targetDir, filename);
+      writeFileSync(targetPath, translationResult.content, "utf-8");
       setResult({
         success: true,
         message: `Translated ${selectedSkill.name} to ${selectedAgent.name} format`,
@@ -1812,16 +1651,780 @@ function Context({ rows = 24 }) {
   ] });
 }
 
-// src/App.tsx
+// src/screens/Workflow.tsx
+import { useState as useState12, useEffect as useEffect8 } 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);
+  useEffect8(() => {
+    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 useEffect9 } 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);
+  useEffect9(() => {
+    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 useEffect10 } 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);
+  useEffect10(() => {
+    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 useEffect11 } 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);
+  useEffect11(() => {
+    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 useEffect12 } 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);
+  useEffect12(() => {
+    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/App.tsx
+import { jsx as jsx15, jsxs as jsxs15 } from "react/jsx-runtime";
 function App() {
-  const [screen, setScreen] = useState12("home");
+  const [screen, setScreen] = useState17("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",
+    ",": "settings"
+  };
+  useInput13((input, key) => {
     if (input === "q") {
       exit();
       return;
@@ -1830,65 +2433,71 @@ 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__ */ jsx15(Home, { onNavigate: setScreen, cols, rows });
       case "browse":
-        return /* @__PURE__ */ jsx10(Browse, { cols, rows });
+        return /* @__PURE__ */ jsx15(Browse, { cols, rows });
       case "installed":
-        return /* @__PURE__ */ jsx10(Installed, { cols, rows });
+        return /* @__PURE__ */ jsx15(Installed, { cols, rows });
       case "sync":
-        return /* @__PURE__ */ jsx10(Sync, { cols, rows });
+        return /* @__PURE__ */ jsx15(Sync, { cols, rows });
       case "settings":
-        return /* @__PURE__ */ jsx10(Settings, { cols, rows });
+        return /* @__PURE__ */ jsx15(Settings, { cols, rows });
       case "recommend":
-        return /* @__PURE__ */ jsx10(Recommend, { cols, rows });
+        return /* @__PURE__ */ jsx15(Recommend, { cols, rows });
       case "translate":
-        return /* @__PURE__ */ jsx10(Translate, { cols, rows });
+        return /* @__PURE__ */ jsx15(Translate, { cols, rows });
       case "context":
-        return /* @__PURE__ */ jsx10(Context, { cols, rows });
+        return /* @__PURE__ */ jsx15(Context, { cols, rows });
+      case "workflow":
+        return /* @__PURE__ */ jsx15(Workflow, { cols, rows });
+      case "execute":
+        return /* @__PURE__ */ jsx15(Execute, { cols, rows });
+      case "history":
+        return /* @__PURE__ */ jsx15(History, { cols, rows });
+      case "marketplace":
+        return /* @__PURE__ */ jsx15(Marketplace, { cols, rows });
+      case "memory":
+        return /* @__PURE__ */ jsx15(Memory, { 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__ */ 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() })
     ] }),
-    /* @__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__ */ 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" }) })
   ] });
 }
 
 // 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 Box16, Text as Text16 } from "ink";
+import { jsx as jsx16, jsxs as jsxs16 } 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__ */ 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: [
         symbols.star,
         " ",
         count
       ] })
     ] }),
-    subtitle && /* @__PURE__ */ jsx11(Text11, { color: colors.secondaryDim, dimColor: true, children: subtitle })
+    subtitle && /* @__PURE__ */ jsx16(Text16, { 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 Box17, Text as Text17 } from "ink";
+import { jsx as jsx17, jsxs as jsxs17 } from "react/jsx-runtime";
 function formatInstalls(count) {
   if (count >= 1e3) {
     return `${(count / 1e3).toFixed(1)}K`;
@@ -1904,13 +2513,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__ */ jsx17(Box17, { children: /* @__PURE__ */ jsx17(Text17, { 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__ */ jsxs17(Box17, { flexDirection: "column", children: [
+    showRank && /* @__PURE__ */ jsx17(Box17, { marginBottom: 1, children: /* @__PURE__ */ jsxs17(Text17, { color: colors.secondaryDim, children: [
       "  #  SKILL",
       showSource && "                         SOURCE",
       showInstalls && "        INSTALLS"
@@ -1920,9 +2529,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__ */ jsxs17(Box17, { children: [
+        /* @__PURE__ */ jsxs17(
+          Text17,
           {
             color: isSelected ? colors.primary : colors.secondary,
             bold: isSelected,
@@ -1935,14 +2544,14 @@ function SkillList({
             ]
           }
         ),
-        showSource && /* @__PURE__ */ jsxs12(Text12, { color: colors.secondaryDim, dimColor: !isSelected, children: [
+        showSource && /* @__PURE__ */ jsxs17(Text17, { 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__ */ jsx17(Text17, { 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__ */ jsx17(Box17, { marginTop: 1, children: /* @__PURE__ */ jsxs17(Text17, { color: colors.secondaryDim, dimColor: true, children: [
       "Showing ",
       startIndex + 1,
       "-",
@@ -1954,11 +2563,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 Box18, Text as Text18 } from "ink";
+import { jsx as jsx18, jsxs as jsxs18 } from "react/jsx-runtime";
 function StatusBar({ shortcuts, message }) {
-  return /* @__PURE__ */ jsxs13(
-    Box13,
+  return /* @__PURE__ */ jsxs18(
+    Box18,
     {
       borderStyle: "single",
       borderColor: colors.borderDim,
@@ -1969,11 +2578,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__ */ 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 })
         ] }, idx)) }),
-        message && /* @__PURE__ */ jsxs13(Text13, { color: colors.success, children: [
+        message && /* @__PURE__ */ jsxs18(Text18, { color: colors.success, children: [
           symbols.check,
           " ",
           message
@@ -1984,44 +2593,44 @@ function StatusBar({ shortcuts, message }) {
 }
 
 // src/components/SearchInput.tsx
-import { Box as Box14, Text as Text14 } from "ink";
+import { Box as Box19, Text as Text19 } from "ink";
 import TextInput from "ink-text-input";
-import { jsx as jsx14, jsxs as jsxs14 } from "react/jsx-runtime";
+import { jsx as jsx19, jsxs as jsxs19 } from "react/jsx-runtime";
 function SearchInput({
   value,
   onChange,
   placeholder = "Search skills...",
   isFocused = false
 }) {
-  return /* @__PURE__ */ jsxs14(
-    Box14,
+  return /* @__PURE__ */ jsxs19(
+    Box19,
     {
       borderStyle: "single",
       borderColor: isFocused ? colors.primary : colors.borderDim,
       paddingX: 1,
       children: [
-        /* @__PURE__ */ jsx14(Text14, { color: colors.secondaryDim, children: "/ " }),
-        isFocused ? /* @__PURE__ */ jsx14(
+        /* @__PURE__ */ jsx19(Text19, { color: colors.secondaryDim, children: "/ " }),
+        isFocused ? /* @__PURE__ */ jsx19(
           TextInput,
           {
             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__ */ jsx19(Text19, { color: value ? colors.secondary : colors.secondaryDim, children: value || placeholder }),
+        /* @__PURE__ */ jsx19(Box19, { flexGrow: 1 }),
+        /* @__PURE__ */ jsx19(Text19, { 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 useState18, useCallback as useCallback3, useEffect as useEffect13 } from "react";
+import { useInput as useInput14, useApp as useApp2 } from "ink";
 function useKeyboard(options = {}) {
   const { exit } = useApp2();
-  useInput9((input, key) => {
+  useInput14((input, key) => {
     if (options.disabled) return;
     if (input === "q" || key.ctrl && input === "c") {
       exit();
@@ -2065,8 +2674,8 @@ function useKeyboard(options = {}) {
   });
 }
 function useListNavigation(listLength, initialIndex = 0) {
-  const [selectedIndex, setSelectedIndex] = useState13(initialIndex);
-  useEffect8(() => {
+  const [selectedIndex, setSelectedIndex] = useState18(initialIndex);
+  useEffect13(() => {
     if (selectedIndex >= listLength && listLength > 0) {
       setSelectedIndex(listLength - 1);
     }
@@ -2083,11 +2692,122 @@ function useListNavigation(listLength, initialIndex = 0) {
   return { selectedIndex, setSelectedIndex, moveUp, moveDown, reset };
 }
 
+// src/hooks/useMemory.ts
+import { useState as useState19, useEffect as useEffect14, 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] = 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 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]
+  );
+  useEffect14(() => {
+    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 jsx20 } 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__ */ jsx20(App, {}), {
     exitOnCtrlC: true
   });
   return waitUntilExit().then(() => {
@@ -2098,9 +2818,13 @@ export {
   App,
   Browse,
   Context,
+  Execute,
   Header,
+  History,
   Home,
   Installed,
+  Marketplace,
+  Memory,
   Recommend,
   SearchInput,
   Settings,
@@ -2109,6 +2833,7 @@ export {
   StatusBar,
   Sync,
   Translate,
+  Workflow,
   colors,
   logo,
   startTUI,
@@ -2116,6 +2841,7 @@ export {
   useKeyboard,
   useListNavigation,
   useMarketplace,
+  useMemory,
   useRecommend,
   useSkills
 };