@geminilight/mindos 0.5.70 → 0.6.0

package/app/hooks/useSlashCommand.ts

@@ -0,0 +1,114 @@
+'use client';
+
+import { useState, useCallback, useEffect, useRef } from 'react';
+import type { SkillInfo } from '@/components/settings/types';
+
+export interface SlashItem {
+  type: 'skill';
+  name: string;
+  description: string;
+}
+
+function safeFetchSkills(): Promise<SkillInfo[]> {
+  return fetch('/api/skills')
+    .then((r) => (r.ok ? r.json() : { skills: [] }))
+    .then((data) => (Array.isArray(data?.skills) ? data.skills : []))
+    .catch(() => [] as SkillInfo[]);
+}
+
+export function useSlashCommand() {
+  const [allSkills, setAllSkills] = useState<SkillInfo[]>([]);
+  const [slashQuery, setSlashQuery] = useState<string | null>(null);
+  const [slashResults, setSlashResults] = useState<SlashItem[]>([]);
+  const [slashIndex, setSlashIndex] = useState(0);
+  const loaded = useRef(false);
+
+  const loadSkills = useCallback(async () => {
+    const skills = await safeFetchSkills();
+    setAllSkills(skills.filter((s) => s.enabled));
+    loaded.current = true;
+  }, []);
+
+  useEffect(() => {
+    loadSkills();
+    const handler = () => loadSkills();
+    window.addEventListener('mindos:skills-changed', handler);
+    return () => window.removeEventListener('mindos:skills-changed', handler);
+  }, [loadSkills]);
+
+  const updateSlashFromInput = useCallback(
+    (val: string, cursorPos: number) => {
+      const before = val.slice(0, cursorPos);
+      const slashIdx = before.lastIndexOf('/');
+
+      if (slashIdx === -1) {
+        setSlashQuery(null);
+        return;
+      }
+
+      // `/` must be at line start or preceded by whitespace
+      if (slashIdx > 0 && before[slashIdx - 1] !== ' ' && before[slashIdx - 1] !== '\n') {
+        setSlashQuery(null);
+        return;
+      }
+
+      // No space in the typed query — slash commands are single tokens
+      const query = before.slice(slashIdx + 1);
+      if (query.includes(' ')) {
+        setSlashQuery(null);
+        return;
+      }
+
+      if (!loaded.current) {
+        loadSkills();
+        setSlashQuery(null);
+        return;
+      }
+
+      const q = query.toLowerCase();
+      const items: SlashItem[] = allSkills
+        .filter((s) => s.name.toLowerCase().includes(q) || s.description.toLowerCase().includes(q))
+        .slice(0, 20)
+        .map((s) => ({ type: 'skill', name: s.name, description: s.description }));
+
+      if (items.length === 0) {
+        setSlashQuery(null);
+        setSlashResults([]);
+        setSlashIndex(0);
+        return;
+      }
+
+      setSlashQuery(query);
+      setSlashResults(items);
+      setSlashIndex(0);
+    },
+    [allSkills, loadSkills],
+  );
+
+  const navigateSlash = useCallback(
+    (direction: 'up' | 'down') => {
+      if (slashResults.length === 0) return;
+      if (direction === 'down') {
+        setSlashIndex((i) => Math.min(i + 1, slashResults.length - 1));
+      } else {
+        setSlashIndex((i) => Math.max(i - 1, 0));
+      }
+    },
+    [slashResults.length],
+  );
+
+  const resetSlash = useCallback(() => {
+    setSlashQuery(null);
+    setSlashResults([]);
+    setSlashIndex(0);
+  }, []);
+
+  return {
+    slashQuery,
+    slashResults,
+    slashIndex,
+    updateSlashFromInput,
+    navigateSlash,
+    resetSlash,
+  };
+}

package/app/lib/actions.ts

@@ -1,7 +1,10 @@
 'use server';
 
-import { createFile, deleteFile, deleteDirectory, convertToSpace, renameFile, renameSpace, getMindRoot, invalidateCache } from '@/lib/fs';
-import { createSpaceFilesystem } from '@/lib/core/create-space';
+import fs from 'fs';
+import path from 'path';
+import { createFile, deleteFile, deleteDirectory, convertToSpace, renameFile, renameSpace, getMindRoot, invalidateCache, collectAllFiles } from '@/lib/fs';
+import { createSpaceFilesystem, generateReadmeTemplate } from '@/lib/core/create-space';
+import { INSTRUCTION_TEMPLATE, cleanDirName } from '@/lib/core/space-scaffold';
 import { revalidatePath } from 'next/cache';
 
 export async function createFileAction(dirPath: string, fileName: string): Promise<{ success: boolean; filePath?: string; error?: string }> {
@@ -112,3 +115,77 @@ export async function createSpaceAction(
     return { success: false, error: msg };
   }
 }
+
+/**
+ * Revert AI-generated space content back to scaffold templates.
+ * Called when user discards AI initialization from SpaceInitToast.
+ */
+export async function revertSpaceInitAction(
+  spacePath: string,
+  name: string,
+  description: string,
+): Promise<{ success: boolean; error?: string }> {
+  try {
+    const mindRoot = getMindRoot();
+    const absDir = path.resolve(mindRoot, spacePath);
+    if (!absDir.startsWith(mindRoot)) {
+      return { success: false, error: 'Invalid path' };
+    }
+
+    const readmePath = path.join(absDir, 'README.md');
+    const instructionPath = path.join(absDir, 'INSTRUCTION.md');
+
+    const readmeContent = generateReadmeTemplate(spacePath, name, description);
+    fs.writeFileSync(readmePath, readmeContent, 'utf-8');
+
+    const dirName = cleanDirName(name);
+    fs.writeFileSync(instructionPath, INSTRUCTION_TEMPLATE(dirName), 'utf-8');
+
+    invalidateCache();
+    revalidatePath('/', 'layout');
+    return { success: true };
+  } catch (err) {
+    return { success: false, error: err instanceof Error ? err.message : 'Failed to revert' };
+  }
+}
+
+const EXAMPLE_PREFIX = '🧪_example_';
+
+export async function scanExampleFilesAction(): Promise<{ files: string[] }> {
+  const all = collectAllFiles();
+  const examples = all.filter(f => path.basename(f).startsWith(EXAMPLE_PREFIX));
+  return { files: examples };
+}
+
+export async function cleanupExamplesAction(): Promise<{ success: boolean; deleted: number; error?: string }> {
+  try {
+    const { files } = await scanExampleFilesAction();
+    if (files.length === 0) return { success: true, deleted: 0 };
+
+    const root = getMindRoot();
+    for (const relPath of files) {
+      const absPath = path.resolve(root, relPath);
+      if (absPath.startsWith(root) && fs.existsSync(absPath)) {
+        fs.unlinkSync(absPath);
+      }
+    }
+
+    // Clean up empty directories left behind
+    const dirs = new Set(files.map(f => path.dirname(path.resolve(root, f))));
+    const sortedDirs = [...dirs].sort((a, b) => b.length - a.length);
+    for (const dir of sortedDirs) {
+      try {
+        if (dir.startsWith(root) && dir !== root) {
+          const entries = fs.readdirSync(dir);
+          if (entries.length === 0) fs.rmdirSync(dir);
+        }
+      } catch { /* directory not empty or already removed */ }
+    }
+
+    invalidateCache();
+    revalidatePath('/', 'layout');
+    return { success: true, deleted: files.length };
+  } catch (err) {
+    return { success: false, deleted: 0, error: err instanceof Error ? err.message : 'Failed to cleanup' };
+  }
+}

package/app/lib/agent/index.ts

@@ -1,5 +1,5 @@
 export { getModelConfig } from './model';
-export { knowledgeBaseTools, WRITE_TOOLS, truncate } from './tools';
+export { getRequestScopedTools, knowledgeBaseTools, WRITE_TOOLS, truncate } from './tools';
 export { AGENT_SYSTEM_PROMPT } from './prompt';
 export {
   estimateTokens, estimateStringTokens, getContextLimit, needsCompact,

package/app/lib/agent/prompt.ts

@@ -27,6 +27,8 @@ Persona: Methodical, strictly objective, execution-oriented. Zero fluff. Never u
 
 - **Auto-loaded**: Configs, instructions, and SKILL.md are already in your context. Do not search for them unless explicitly asked.
 - **Uploaded Files**: Local files attached by the user appear in the "⚠️ USER-UPLOADED FILES" section below. Use this content directly. Do NOT use tools to read/search them.
+- **Skills**: Use the list_skills and load_skill tools to discover available skills on demand.
+- **MCP**: The MindOS MCP server is built-in. Use list_mcp_tools and call_mcp_tool to inspect and invoke additional MCP tools configured in ~/.mindos/mcp.json.
 
 ## Output
 

package/app/lib/agent/tools.ts

@@ -1,3 +1,4 @@
+import path from 'path';
 import { Type, type Static } from '@sinclair/typebox';
 import type { AgentTool, AgentToolResult } from '@mariozechner/pi-agent-core';
 import {
@@ -6,6 +7,8 @@ import {
   deleteFile, renameFile, moveFile, findBacklinks, gitLog, gitShowFile, appendCsvRow,
   getMindRoot,
 } from '@/lib/fs';
+import { readSkillContentByName, scanSkillDirs } from '@/lib/pi-integration/skills';
+import { callMcporterTool, createMcporterAgentTools, listMcporterServers, listMcporterTools } from '@/lib/pi-integration/mcporter';
 
 // Max chars per file to avoid token overflow (~100k chars ≈ ~25k tokens)
 const MAX_FILE_CHARS = 20_000;
@@ -146,6 +149,22 @@ const CsvAppendParams = Type.Object({
   row: Type.Array(Type.String(), { description: 'Array of cell values for the new row' }),
 });
 
+const ListSkillsParams = Type.Object({});
+
+const LoadSkillParams = Type.Object({
+  name: Type.String({ description: 'Skill name, e.g. "mindos" or "context7"' }),
+});
+
+const ListMcpToolsParams = Type.Object({
+  server: Type.Optional(Type.String({ description: 'Optional MCP server name. Omit to list discovered servers only.' })),
+});
+
+const CallMcpToolParams = Type.Object({
+  server: Type.String({ description: 'MCP server name discovered via list_mcp_tools' }),
+  tool: Type.String({ description: 'Exact MCP tool name to invoke' }),
+  arguments_json: Type.Optional(Type.String({ description: 'Optional JSON object string of tool arguments. Example: {"query":"react hooks"}' })),
+});
+
 // ─── Tool Definitions (AgentTool interface) ─────────────────────────────────
 
 // Write-operation tool names — used by beforeToolCall for write-protection
@@ -154,6 +173,28 @@ export const WRITE_TOOLS = new Set([
   'update_section', 'edit_lines', 'delete_file', 'rename_file', 'move_file', 'append_csv',
 ]);
 
+export async function getRequestScopedTools(): Promise<AgentTool<any>[]> {
+  try {
+    const result = await listMcporterServers();
+    const okServers = (result.servers ?? []).filter((server) => server.status === 'ok');
+    if (okServers.length === 0) return knowledgeBaseTools;
+
+    const detailedServers = await Promise.all(okServers.map(async (server) => {
+      try {
+        return await listMcporterTools(server.name);
+      } catch {
+        return server;
+      }
+    }));
+
+    const dynamicMcpTools = createMcporterAgentTools(detailedServers);
+    if (dynamicMcpTools.length === 0) return knowledgeBaseTools;
+    return [...knowledgeBaseTools, ...dynamicMcpTools];
+  } catch {
+    return knowledgeBaseTools;
+  }
+}
+
 export const knowledgeBaseTools: AgentTool<any>[] = [
   {
     name: 'list_files',
@@ -251,6 +292,71 @@ export const knowledgeBaseTools: AgentTool<any>[] = [
     }),
   },
 
+  {
+    name: 'list_skills',
+    label: 'List Skills',
+    description: 'List available MindOS skills discovered from app/data/skills, skills, {mindRoot}/.skills, and ~/.mindos/skills. Use this before load_skill when you need a skill by name.',
+    parameters: ListSkillsParams,
+    execute: safeExecute(async () => {
+      const projectRoot = process.env.MINDOS_PROJECT_ROOT || path.resolve(process.cwd(), '..');
+      const skills = scanSkillDirs({ projectRoot, mindRoot: getMindRoot() });
+      if (skills.length === 0) return textResult('No skills found.');
+      return textResult(skills.map((skill) => `- **${skill.name}** [${skill.origin}]${skill.enabled ? '' : ' (disabled)'} — ${skill.description || 'No description'}\n  Path: ${skill.path}`).join('\n'));
+    }),
+  },
+
+  {
+    name: 'load_skill',
+    label: 'Load Skill',
+    description: 'Load the full content of a specific skill by name. Use list_skills first if you do not know the exact skill name.',
+    parameters: LoadSkillParams,
+    execute: safeExecute(async (_id, params: Static<typeof LoadSkillParams>) => {
+      const projectRoot = process.env.MINDOS_PROJECT_ROOT || path.resolve(process.cwd(), '..');
+      const content = readSkillContentByName(params.name, { projectRoot, mindRoot: getMindRoot() });
+      if (!content) return textResult(`Skill not found: ${params.name}`);
+      return textResult(truncate(content));
+    }),
+  },
+
+  {
+    name: 'list_mcp_tools',
+    label: 'List MCP Tools',
+    description: 'List MCP servers configured in ~/.mindos/mcp.json. Without `server`, lists discovered servers and their health. With `server`, lists that server\'s tools and JSON schemas.',
+    parameters: ListMcpToolsParams,
+    execute: safeExecute(async (_id, params: Static<typeof ListMcpToolsParams>) => {
+      if (!params.server) {
+        const result = await listMcporterServers();
+        if (!result.servers || result.servers.length === 0) return textResult('No external MCP servers configured. The MindOS built-in MCP server is always available.');
+        return textResult(result.servers.map((server) => `- **${server.name}** — status: ${server.status}${server.transport ? ` | transport: ${server.transport}` : ''}${server.error ? ` | error: ${server.error}` : ''}`).join('\n'));
+      }
+
+      const server = await listMcporterTools(params.server);
+      if (!server.tools || server.tools.length === 0) {
+        return textResult(`No tools found for MCP server: ${params.server}`);
+      }
+      return textResult(server.tools.map((tool) => `## ${tool.name}\n${tool.description || 'No description'}\n\nSchema:\n${JSON.stringify(tool.inputSchema ?? {}, null, 2)}`).join('\n\n'));
+    }),
+  },
+
+  {
+    name: 'call_mcp_tool',
+    label: 'Call MCP Tool',
+    description: 'Call a specific MCP tool by server and tool name. Pass `arguments_json` as a JSON object string. Use list_mcp_tools first to discover names and schemas.',
+    parameters: CallMcpToolParams,
+    execute: safeExecute(async (_id, params: Static<typeof CallMcpToolParams>) => {
+      let parsedArgs: Record<string, unknown> = {};
+      if (params.arguments_json?.trim()) {
+        try {
+          parsedArgs = JSON.parse(params.arguments_json) as Record<string, unknown>;
+        } catch (error) {
+          return textResult(`Invalid arguments_json. Expected a JSON object string. Error: ${formatToolError(error)}`);
+        }
+      }
+      const output = await callMcporterTool(params.server, params.tool, parsedArgs);
+      return textResult(output || '(empty MCP response)');
+    }),
+  },
+
   {
     name: 'web_search',
     label: 'Web Search',

package/app/lib/core/create-space.ts

@@ -1,6 +1,16 @@
 import { MindOSError, ErrorCodes } from '@/lib/errors';
 import { createFile } from './fs-ops';
 
+/**
+ * Generate the template README.md content for a new space.
+ * Extracted so both createSpaceFilesystem and revert can produce identical content.
+ */
+export function generateReadmeTemplate(fullPath: string, name: string, description: string): string {
+  const cleanName = name.replace(/^[\p{Emoji_Presentation}\p{Extended_Pictographic}\s]+/u, '') || name;
+  const desc = description.trim() || '(Describe the purpose and usage of this space.)';
+  return `# ${cleanName}\n\n${desc}\n\n## 📁 Structure\n\n\`\`\`bash\n${fullPath}/\n├── INSTRUCTION.md\n├── README.md\n└── (your files here)\n\`\`\`\n\n## 💡 Usage\n\n(Add usage guidelines for this space.)\n`;
+}
+
 /**
  * Create a Mind Space on disk: `{fullPath}/README.md` plus scaffold from {@link createFile} / scaffoldIfNewSpace.
  * Caller must invalidate app file-tree cache (e.g. `invalidateCache()` in `lib/fs.ts`).
@@ -26,10 +36,7 @@ export function createSpaceFilesystem(
 
   const prefix = cleanParent ? `${cleanParent}/` : '';
   const fullPath = `${prefix}${trimmed}`;
-
-  const cleanName = trimmed.replace(/^[\p{Emoji_Presentation}\p{Extended_Pictographic}\s]+/u, '') || trimmed;
-  const desc = description.trim() || '(Describe the purpose and usage of this space.)';
-  const readmeContent = `# ${cleanName}\n\n${desc}\n\n## 📁 Structure\n\n\`\`\`bash\n${fullPath}/\n├── INSTRUCTION.md\n├── README.md\n└── (your files here)\n\`\`\`\n\n## 💡 Usage\n\n(Add usage guidelines for this space.)\n`;
+  const readmeContent = generateReadmeTemplate(fullPath, trimmed, description);
 
   createFile(mindRoot, `${fullPath}/README.md`, readmeContent);
   return { path: fullPath };

package/app/lib/core/index.ts

@@ -61,7 +61,7 @@ export { findBacklinks } from './backlinks';
 export { isGitRepo, gitLog, gitShowFile } from './git';
 
 // Mind Space
-export { createSpaceFilesystem } from './create-space';
+export { createSpaceFilesystem, generateReadmeTemplate } from './create-space';
 export { summarizeTopLevelSpaces } from './list-spaces';
 export type { MindSpaceSummary } from './list-spaces';
 

package/app/lib/i18n-en.ts

@@ -28,6 +28,11 @@ export const en = {
     aiInit: 'AI initialize content',
     aiInitHint: 'AI will generate README and INSTRUCTION for this space',
     aiInitNoKey: 'Configure an API key in Settings → AI to enable',
+    aiInitGenerating: (name: string) => `Generating content for ${name}`,
+    aiInitReady: (name: string) => `${name} ready`,
+    aiInitReview: 'Review',
+    aiInitDiscard: 'Discard',
+    aiInitReverted: (name: string) => `${name} reverted to template`,
     createSpace: 'Create',
     cancelCreate: 'Cancel',
     continueEditing: 'Continue editing',
@@ -53,6 +58,9 @@ export const en = {
       hoursAgo: (n: number) => `${n}h ago`,
       daysAgo: (n: number) => `${n}d ago`,
     },
+    cleanupExamples: (n: number) => `${n} example file${n > 1 ? 's' : ''} from the template can be removed`,
+    cleanupExamplesButton: 'Clean up',
+    cleanupExamplesDone: 'Example files removed',
   },
   sidebar: {
     files: 'Spaces',
@@ -97,7 +105,7 @@ export const en = {
   },
   ask: {
     title: 'MindOS Agent',
-    placeholder: 'Ask a question... or type @ to attach a file',
+    placeholder: 'Ask a question... @ files, / skills',
     emptyPrompt: 'Ask anything about your knowledge base',
     send: 'send',
     newlineHint: 'new line',
@@ -105,7 +113,9 @@ export const en = {
     panelComposerFooter: 'Resize height',
     panelComposerResetHint: 'Double-click to reset height',
     panelComposerKeyboard: 'Arrow keys adjust height; Home/End min/max',
-    attachFile: 'attach file',
+    attachFile: 'Context',
+    uploadedFiles: 'Uploaded',
+    skillsHint: 'skills',
     attachCurrent: 'attach current file',
     stopTitle: 'Stop',
     connecting: 'Thinking with your mind...',
@@ -351,6 +361,9 @@ export const en = {
       enabledUnit: (n: number) => `${n} enabled`,
       agentCount: (n: number) => `${n} agent${n !== 1 ? 's' : ''}`,
       runtimeActive: 'Active',
+      riskMcpStopped: 'MCP server is not running.',
+      riskDetected: (n: number) => `${n} detected agent(s) need configuration.`,
+      riskSkillsDisabled: 'All skills are disabled.',
     },
     mcp: {
       title: 'MCP Connections',
@@ -384,6 +397,7 @@ export const en = {
       riskMcpStopped: 'MCP server is not running.',
       riskDetected: (n: number) => `${n} detected agent(s) need configuration.`,
       riskNotFound: (n: number) => `${n} agent(s) not found on this machine.`,
+      riskSkillsDisabled: 'All skills are disabled.',
       bulkReconnectFiltered: 'Reconnect all',
       bulkRunning: 'Running reconnect...',
       bulkSummary: (ok: number, failed: number) => `Reconnected ${ok}, failed ${failed}.`,
@@ -792,6 +806,15 @@ export const en = {
       authTokenResetConfirm: 'Regenerate token? All existing MCP clients will need to update their config.',
       authTokenMcpPort: 'MCP port',
       restartWalkthrough: 'Restart walkthrough',
+      showHiddenFiles: 'Show hidden files',
+      showHiddenFilesHint: 'Display dot-prefixed folders (.agents, .claude, .mindos, etc.) in the file tree.',
+      cleanupExamples: 'Clean up example files',
+      cleanupExamplesHint: 'Remove all template example files (🧪_example_*) from your knowledge base.',
+      cleanupExamplesButton: 'Clean up',
+      cleanupExamplesNone: 'No example files found',
+      cleanupExamplesConfirm: (n: number) => `Delete ${n} example file${n > 1 ? 's' : ''}? This cannot be undone.`,
+      cleanupExamplesDone: (n: number) => `Removed ${n} example file${n > 1 ? 's' : ''}`,
+      cleanupExamplesScanning: 'Scanning...',
     },
     sync: {
       emptyTitle: 'Cross-device Sync',
@@ -1143,50 +1166,36 @@ export const en = {
     welcomeLinkMCP: 'MCP Settings',
   },
   guide: {
-    title: 'Get Started with MindOS',
+    title: 'Quick Start',
     showGuide: 'Show getting started guide',
     close: 'Close',
     skip: 'Skip',
-    kb: {
-      title: 'Explore your knowledge base',
-      cta: 'Start',
-      fullDesc: 'Your knowledge base has 6 areas — try clicking one:',
-      dirs: {
-        profile: 'Who you are, preferences, goals',
-        notes: 'Daily capture: ideas, meetings, todos',
-        connections: 'Your network of people',
-        workflows: 'Reusable process SOPs',
-        resources: 'Structured data: product lists, tool lists',
-        projects: 'Project plans and progress',
-      },
-      instructionHint: 'Click INSTRUCTION.md to see how AI agents behave.',
-      emptyDesc: 'Your knowledge base has 3 core files:',
-      emptyFiles: {
-        instruction: 'INSTRUCTION.md — Rules that all AI agents follow',
-        readme: 'README.md — Directory index and navigation',
-        config: 'CONFIG.json — Machine-readable preferences',
-      },
-      emptyHint: 'Create your own folder structure anytime.',
-      progress: (n: number) => `Browsed ${n}/1 file`,
-      done: 'Done',
+    import: {
+      title: 'Import your files',
+      cta: 'Import',
+      desc: 'Upload your resume, project docs, or notes — anything you want AI agents to know about you.',
+      button: 'Import Files',
     },
     ai: {
-      title: 'Chat with AI',
-      cta: 'Start',
-      prompt: 'Read my knowledge base and help me write a self-introduction into Profile.',
+      title: 'See AI read your content',
+      cta: 'Try it',
+      desc: 'Your files are in the knowledge base. Ask MindOS Agent what it learned:',
+      prompt: 'Introduce me based on my knowledge base — who am I and what am I working on?',
       promptEmpty: 'Help me design a knowledge base folder structure that fits my needs',
     },
-    sync: {
-      title: 'Sync Notes',
-      optional: 'Optional',
-      cta: 'Configure',
+    agent: {
+      title: 'Try in another Agent',
+      cta: 'Copy prompt',
+      desc: 'Open Cursor, Claude Code, or any MCP-connected Agent and paste this:',
+      copyPrompt: 'Read my MindOS knowledge base and summarize my background, then suggest what I should focus on next.',
+      copy: 'Copy',
+      copied: 'Copied!',
     },
     done: {
       title: "You're all set!",
       titleFinal: "You've mastered MindOS essentials!",
       steps: [
-        { hint: 'Next: try saving an article →', prompt: 'Help me save the key points from this article into MindOS.' },
-        { hint: 'Next: try using your KB in another Agent →', prompt: 'Help me start coding based on the plan in MindOS.' },
+        { hint: 'Next: try saving an article into your KB →', prompt: 'Help me save the key points from this article into MindOS.' },
         { hint: 'Next: try turning experience into a reusable SOP →', prompt: 'Help me distill this conversation into a reusable workflow in MindOS.' },
       ],
     },
@@ -1267,24 +1276,20 @@ prompt: "Here's my resume, read it and organize my info into MindOS.",
     exploreCta: 'Explore what you can do →',
     steps: [
       {
-        title: 'Navigation',
-        body: 'This is your Activity Bar — switch between Files, Search, Plugins, and Agents from here.',
-      },
-      {
-        title: 'Your Knowledge Base',
-        body: 'Browse and organize your notes, profiles, and projects in the file panel.',
+        title: 'Your Project Memory',
+        body: 'Organize projects, SOPs, and preferences in Spaces. Everything is local-first and under your control.',
       },
       {
-        title: 'Ask AI',
-        body: 'Chat with an AI that knows your entire knowledge base. Press ⌘/ anytime.',
+        title: 'AI That Already Knows You',
+        body: 'MindOS Agent reads your entire knowledge base automatically. Ask about your projects — no need to re-explain anything.',
       },
       {
-        title: 'Quick Search',
-        body: 'Find any file instantly with ⌘K — search across all your notes.',
+        title: 'Connect Any Agent',
+        body: 'Link Cursor, Claude Code, or Windsurf via MCP — they all share the same project memory.',
       },
       {
-        title: 'Settings',
-        body: 'Configure AI providers, MCP connections, sync, and appearance here.',
+        title: 'Echo — Growth Compounds',
+        body: 'About you, daily reflections, growth tracking — MindOS helps you accumulate cognitive compound interest over time.',
       },
     ],
   },