@geminilight/mindos 0.5.18 → 0.5.20

package/app/lib/agent/tools.ts

@@ -4,6 +4,7 @@ import {
   searchFiles, getFileContent, getFileTree, getRecentlyModified,
   saveFileContent, createFile, appendToFile, insertAfterHeading, updateSection,
   deleteFile, renameFile, moveFile, findBacklinks, gitLog, gitShowFile, appendCsvRow,
+  getMindRoot,
 } from '@/lib/fs';
 import { assertNotProtected } from '@/lib/core';
 import { logAgentOp } from './log';
@@ -21,7 +22,13 @@ export function assertWritable(filePath: string): void {
   assertNotProtected(filePath, 'modified by AI agent');
 }
 
-/** Helper: wrap a tool execute fn with agent-op logging */
+/**
+ * Wrap a tool execute fn with agent-op logging.
+ * Catches ALL exceptions and returns an error string — never throws.
+ * This is critical: an unhandled throw from a tool execute function kills
+ * the AI SDK stream and corrupts the session message state, causing
+ * "Cannot read properties of undefined" on every subsequent request.
+ */
 function logged<P extends Record<string, unknown>>(
   toolName: string,
   fn: (params: P) => Promise<string>,
@@ -31,12 +38,12 @@ function logged<P extends Record<string, unknown>>(
     try {
       const result = await fn(params);
       const isError = result.startsWith('Error:');
-      logAgentOp({ ts, tool: toolName, params, result: isError ? 'error' : 'ok', message: result.slice(0, 200) });
+      try { logAgentOp({ ts, tool: toolName, params, result: isError ? 'error' : 'ok', message: result.slice(0, 200) }); } catch { /* logging must never kill the stream */ }
       return result;
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e);
-      logAgentOp({ ts, tool: toolName, params, result: 'error', message: msg.slice(0, 200) });
-      throw e;
+      try { logAgentOp({ ts, tool: toolName, params, result: 'error', message: msg.slice(0, 200) }); } catch { /* swallow — logging must never kill the stream */ }
+      return `Error: ${msg}`;
     }
   };
 }
@@ -47,12 +54,19 @@ export const knowledgeBaseTools = {
   list_files: tool({
     description: 'List files in the knowledge base as an indented tree. Directories beyond `depth` show "... (N items)". Pass `path` to list only a subdirectory, or `depth` to control how deep to expand (default 3).',
     inputSchema: z.object({
-      path: z.string().optional().describe('Optional subdirectory to list (e.g. "Projects/Products"). Omit to list everything.'),
-      depth: z.number().min(1).max(10).optional().describe('Max tree depth to expand (default 3). Directories deeper than this show item count only.'),
+      path: z.string().nullish().describe('Optional subdirectory to list (e.g. "Projects/Products"). Omit to list everything.'),
+      depth: z.number().min(1).max(10).nullish().describe('Max tree depth to expand (default 3). Directories deeper than this show item count only.'),
     }),
     execute: logged('list_files', async ({ path: subdir, depth: maxDepth }) => {
       try {
         const tree = getFileTree();
+
+        // Empty tree at root level → likely a misconfigured mindRoot
+        if (tree.length === 0 && !subdir) {
+          const root = getMindRoot();
+          return `(empty — no .md or .csv files found under mind_root: ${root})`;
+        }
+
         const limit = maxDepth ?? 3;
         const lines: string[] = [];
         function walk(nodes: Array<{ name: string; type: string; children?: unknown[] }>, depth: number) {
@@ -114,9 +128,9 @@ export const knowledgeBaseTools = {
 
   get_recent: tool({
     description: 'Get the most recently modified files in the knowledge base.',
-    inputSchema: z.object({ limit: z.number().min(1).max(50).default(10).describe('Number of files to return') }),
+    inputSchema: z.object({ limit: z.number().min(1).max(50).nullish().describe('Number of files to return (default 10)') }),
     execute: logged('get_recent', async ({ limit }) => {
-      const files = getRecentlyModified(limit);
+      const files = getRecentlyModified(limit ?? 10);
       return files.map(f => `- ${f.path} (${new Date(f.mtime).toISOString()})`).join('\n');
     }),
   }),
@@ -142,12 +156,12 @@ export const knowledgeBaseTools = {
     description: 'Create a new file. Only .md and .csv files are allowed. Parent directories are created automatically.',
     inputSchema: z.object({
       path: z.string().describe('Relative file path (must end in .md or .csv)'),
-      content: z.string().default('').describe('Initial file content'),
+      content: z.string().nullish().describe('Initial file content'),
     }),
     execute: logged('create_file', async ({ path, content }) => {
       try {
         assertWritable(path);
-        createFile(path, content);
+        createFile(path, content ?? '');
         return `File created: ${path}`;
       } catch (e: unknown) {
         return `Error: ${e instanceof Error ? e.message : String(e)}`;
@@ -283,11 +297,11 @@ export const knowledgeBaseTools = {
     description: 'Get git commit history for a file. Shows recent commits that modified this file.',
     inputSchema: z.object({
       path: z.string().describe('Relative file path'),
-      limit: z.number().min(1).max(50).default(10).describe('Number of commits to return'),
+      limit: z.number().min(1).max(50).nullish().describe('Number of commits to return (default 10)'),
     }),
     execute: logged('get_history', async ({ path, limit }) => {
       try {
-        const commits = gitLog(path, limit);
+        const commits = gitLog(path, limit ?? 10);
         if (commits.length === 0) return `No git history found for: ${path}`;
         return commits.map(c => `- \`${c.hash.slice(0, 7)}\` ${c.date} — ${c.message} (${c.author})`).join('\n');
       } catch (e: unknown) {

package/app/lib/fs.ts

@@ -59,7 +59,15 @@ function ensureCache(): FileTreeCache {
   if (isCacheValid()) return _cache!;
   const root = getMindRoot();
   const tree = buildFileTree(root);
-  const allFiles = buildAllFiles(root);
+  // Extract all file paths from the tree to avoid a second full traversal.
+  const allFiles: string[] = [];
+  function collect(nodes: FileNode[]) {
+    for (const n of nodes) {
+      if (n.type === 'file') allFiles.push(n.path);
+      else if (n.children) collect(n.children);
+    }
+  }
+  collect(tree);
   _cache = { tree, allFiles, timestamp: Date.now() };
   return _cache;
 }

package/app/lib/i18n.ts

@@ -251,6 +251,14 @@ export const messages = {
         skillLanguage: 'Skill Language',
         skillLangEn: 'English',
         skillLangZh: '中文',
+        searchSkills: 'Search skills...',
+        customGroup: 'Custom',
+        builtinGroup: 'Built-in',
+        noSkillsMatch: (query: string) => `No skills match "${query}"`,
+        skillTemplate: 'Template',
+        skillTemplateGeneral: 'General',
+        skillTemplateToolUse: 'Tool-use',
+        skillTemplateWorkflow: 'Workflow',
         selectDetected: 'Select Detected',
         clearSelection: 'Clear',
         quickSetup: 'Quick Setup',
@@ -722,6 +730,14 @@ export const messages = {
         skillLanguage: 'Skill 语言',
         skillLangEn: 'English',
         skillLangZh: '中文',
+        searchSkills: '搜索 Skill...',
+        customGroup: '自定义',
+        builtinGroup: '内置',
+        noSkillsMatch: (query: string) => `没有匹配「${query}」的 Skill`,
+        skillTemplate: '模板',
+        skillTemplateGeneral: '通用',
+        skillTemplateToolUse: '工具调用',
+        skillTemplateWorkflow: '工作流',
         selectDetected: '选择已检测',
         clearSelection: '清除',
         quickSetup: '快速配置',

package/app/lib/settings.ts

@@ -25,6 +25,15 @@ export interface AgentConfig {
   contextStrategy?: 'auto' | 'off'; // default 'auto'
 }
 
+export interface GuideState {
+  active: boolean;        // setup 完成时写入 true
+  dismissed: boolean;     // 用户关闭 Guide Card 时写入 true
+  template: 'en' | 'zh' | 'empty';  // setup 时写入
+  step1Done: boolean;     // 至少浏览过 1 个文件
+  askedAI: boolean;       // 至少发过 1 条 AI 消息
+  nextStepIndex: number;  // 0=C2, 1=C3, 2=C4, 3=全部完成
+}
+
 export interface ServerSettings {
   ai: AiConfig;
   agent?: AgentConfig;
@@ -36,6 +45,7 @@ export interface ServerSettings {
   startMode?: 'dev' | 'start' | 'daemon';
   setupPending?: boolean;  // true → / redirects to /setup
   disabledSkills?: string[];
+  guideState?: GuideState;
 }
 
 const DEFAULTS: ServerSettings = {
@@ -119,6 +129,23 @@ function parseAgent(raw: unknown): AgentConfig | undefined {
   return Object.keys(result).length > 0 ? result : undefined;
 }
 
+/** Parse guideState from unknown input */
+function parseGuideState(raw: unknown): GuideState | undefined {
+  if (!raw || typeof raw !== 'object') return undefined;
+  const obj = raw as Record<string, unknown>;
+  if (obj.active !== true) return undefined;
+  const template = obj.template === 'en' || obj.template === 'zh' || obj.template === 'empty'
+    ? obj.template : 'en';
+  return {
+    active: true,
+    dismissed: obj.dismissed === true,
+    template,
+    step1Done: obj.step1Done === true,
+    askedAI: obj.askedAI === true,
+    nextStepIndex: typeof obj.nextStepIndex === 'number' ? obj.nextStepIndex : 0,
+  };
+}
+
 export function readSettings(): ServerSettings {
   try {
     const raw = fs.readFileSync(SETTINGS_PATH, 'utf-8');
@@ -134,6 +161,7 @@ export function readSettings(): ServerSettings {
       startMode:   typeof parsed.startMode   === 'string' ? parsed.startMode as ServerSettings['startMode'] : undefined,
       setupPending: parsed.setupPending === true ? true : undefined,
       disabledSkills: Array.isArray(parsed.disabledSkills) ? parsed.disabledSkills as string[] : undefined,
+      guideState: parseGuideState(parsed.guideState),
     };
   } catch {
     return { ...DEFAULTS, ai: { ...DEFAULTS.ai, providers: { ...DEFAULTS.ai.providers } } };
@@ -154,6 +182,7 @@ export function writeSettings(settings: ServerSettings): void {
   if (settings.mcpPort     !== undefined) merged.mcpPort     = settings.mcpPort;
   if (settings.startMode   !== undefined) merged.startMode   = settings.startMode;
   if (settings.disabledSkills !== undefined) merged.disabledSkills = settings.disabledSkills;
+  if (settings.guideState !== undefined) merged.guideState = settings.guideState;
   // setupPending: false/undefined → remove the field (cleanup); true → set it
   if ('setupPending' in settings) {
     if (settings.setupPending) merged.setupPending = true;

package/app/next-env.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="next" />
 /// <reference types="next/image-types/global" />
-import "./.next/types/routes.d.ts";
+import "./.next/dev/types/routes.d.ts";
 
 // NOTE: This file should not be edited
 // see https://nextjs.org/docs/app/api-reference/config/typescript for more information.

package/app/next.config.ts

@@ -8,6 +8,13 @@ const nextConfig: NextConfig = {
   turbopack: {
     root: path.join(__dirname),
   },
+  // Disable client-side router cache for dynamic layouts so that
+  // router.refresh() always fetches a fresh file tree from the server.
+  experimental: {
+    staleTimes: {
+      dynamic: 0,
+    },
+  },
 };
 
 export default nextConfig;

package/bin/cli.js

@@ -39,13 +39,13 @@
  */
 
 import { execSync } from 'node:child_process';
-import { existsSync, readFileSync, writeFileSync, rmSync } from 'node:fs';
+import { existsSync, readFileSync, writeFileSync, rmSync, mkdirSync, cpSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { homedir } from 'node:os';
 
 import { ROOT, CONFIG_PATH, BUILD_STAMP, LOG_PATH, MINDOS_DIR } from './lib/constants.js';
 import { bold, dim, cyan, green, red, yellow } from './lib/colors.js';
-import { run } from './lib/utils.js';
+import { run, npmInstall } from './lib/utils.js';
 import { loadConfig, getStartMode, isDaemonMode } from './lib/config.js';
 import { needsBuild, writeBuildStamp, clearBuildLock, cleanNextDir, ensureAppDeps } from './lib/build.js';
 import { isPortInUse, assertPortFree } from './lib/port.js';
@@ -268,6 +268,41 @@ const commands = {
     const webPort = process.env.MINDOS_WEB_PORT || '3456';
     const mcpPort = process.env.MINDOS_MCP_PORT || '8781';
 
+    // ── Auto-migrate skill rules (v3 split → v4 merged) ──────────────────
+    try {
+      const cfg = JSON.parse(readFileSync(CONFIG_PATH, 'utf-8'));
+      const mr = cfg.mindRoot;
+      if (mr && existsSync(mr)) {
+        const isZh = cfg.disabledSkills?.includes('mindos');
+        const sName = isZh ? 'mindos-zh' : 'mindos';
+        const lang = isZh ? 'zh' : 'en';
+        const sDir = resolve(mr, '.agents', 'skills', sName);
+        const merged = resolve(sDir, 'skill-rules.md');
+        const legacyRules = resolve(sDir, 'rules.md');
+        // Migrate if legacy exists but merged doesn't
+        if (existsSync(legacyRules) && !existsSync(merged)) {
+          const tpl = resolve(ROOT, 'templates', 'skill-rules', lang, 'skill-rules.md');
+          if (existsSync(tpl)) {
+            cpSync(tpl, merged);
+            for (const f of ['rules.md', 'patterns.md', 'proactive.md']) {
+              const p = resolve(sDir, f);
+              if (existsSync(p)) rmSync(p);
+            }
+            console.log(`  ${green('✓')} ${dim('Skill rules migrated to skill-rules.md')}`);
+          }
+        }
+        // Init if .agents/skills/ doesn't exist at all
+        if (!existsSync(sDir)) {
+          const srcDir = resolve(ROOT, 'templates', 'skill-rules', lang);
+          if (existsSync(srcDir)) {
+            mkdirSync(sDir, { recursive: true });
+            cpSync(srcDir, sDir, { recursive: true });
+            console.log(`  ${green('✓')} ${dim('Skill rules initialized')}`);
+          }
+        }
+      }
+    } catch { /* best-effort, don't block startup */ }
+
     // When launched by a daemon manager (launchd/systemd), wait for ports to
     // free instead of exiting immediately — the previous instance may still be
     // shutting down after a restart/update.
@@ -325,13 +360,7 @@ const commands = {
     const mcpSdk = resolve(ROOT, 'mcp', 'node_modules', '@modelcontextprotocol', 'sdk', 'package.json');
     if (!existsSync(mcpSdk)) {
       console.log(yellow('Installing MCP dependencies (first run)...\n'));
-      const mcpCwd = resolve(ROOT, 'mcp');
-      try {
-        execSync('npm install --prefer-offline --no-workspaces', { cwd: mcpCwd, stdio: 'inherit' });
-      } catch {
-        console.log(yellow('Offline install failed, retrying online...\n'));
-        run('npm install --no-workspaces', mcpCwd);
-      }
+      npmInstall(resolve(ROOT, 'mcp'), '--no-workspaces');
     }
     // Map config env vars to what the MCP server expects
     const mcpPort = process.env.MINDOS_MCP_PORT || '8781';
@@ -406,6 +435,80 @@ ${dim('Shortcut: mindos start --daemon  →  install + start in one step')}
     await runGatewayCommand(sub);
   },
 
+  // ── init-skills ──────────────────────────────────────────────────────────
+  'init-skills': async () => {
+    const force = process.argv.includes('--force');
+    console.log(`\n${bold('📦 Initialize Skill Rules')}\n`);
+
+    if (!existsSync(CONFIG_PATH)) {
+      console.log(`  ${red('✘')} Config not found. Run ${cyan('mindos onboard')} first.\n`);
+      process.exit(1);
+    }
+    let config;
+    try {
+      config = JSON.parse(readFileSync(CONFIG_PATH, 'utf-8'));
+    } catch {
+      console.log(`  ${red('✘')} Failed to parse config at ${dim(CONFIG_PATH)}\n`);
+      process.exit(1);
+    }
+    const mindRoot = config.mindRoot;
+    if (!mindRoot || !existsSync(mindRoot)) {
+      console.log(`  ${red('✘')} Knowledge base not found: ${dim(mindRoot || '(not set)')}\n`);
+      process.exit(1);
+    }
+
+    const isZh = config.disabledSkills?.includes('mindos');
+    const skillName = isZh ? 'mindos-zh' : 'mindos';
+    const lang = isZh ? 'zh' : 'en';
+    const skillDir = resolve(mindRoot, '.agents', 'skills', skillName);
+    const sourceDir = resolve(ROOT, 'templates', 'skill-rules', lang);
+
+    if (!existsSync(sourceDir)) {
+      console.log(`  ${red('✘')} Template not found: ${dim(sourceDir)}\n`);
+      process.exit(1);
+    }
+
+    const files = ['skill-rules.md', 'user-rules.md'];
+    mkdirSync(skillDir, { recursive: true });
+
+    let count = 0;
+    for (const file of files) {
+      const dest = resolve(skillDir, file);
+      const src = resolve(sourceDir, file);
+      if (!existsSync(src)) continue;
+
+      // Never overwrite user-rules.md even with --force
+      if (file === 'user-rules.md' && existsSync(dest)) {
+        console.log(`  ${dim('skip')}  ${file} (user rules preserved)`);
+        continue;
+      }
+
+      if (existsSync(dest) && !force) {
+        console.log(`  ${dim('skip')}  ${file} (already exists)`);
+        continue;
+      }
+
+      cpSync(src, dest);
+      console.log(`  ${green('✓')}  ${file}${force ? ' (reset)' : ''}`);
+      count++;
+    }
+
+    // Clean up legacy split files from v3
+    for (const legacy of ['rules.md', 'patterns.md', 'proactive.md']) {
+      const legacyPath = resolve(skillDir, legacy);
+      if (existsSync(legacyPath)) {
+        rmSync(legacyPath);
+        console.log(`  ${dim('cleanup')}  ${legacy} (merged into skill-rules.md)`);
+      }
+    }
+
+    if (count === 0) {
+      console.log(`\n  ${dim('All files already exist. Use --force to reset defaults (user-rules.md is always preserved).')}\n`);
+    } else {
+      console.log(`\n  ${green('✔')} Skill rules initialized at ${dim(skillDir)}\n`);
+    }
+  },
+
   // ── doctor ─────────────────────────────────────────────────────────────────
   doctor: async () => {
     const ok  = (msg) => console.log(`  ${green('✔')} ${msg}`);
@@ -640,6 +743,28 @@ ${dim('Shortcut: mindos start --daemon  →  install + start in one step')}
       console.log(dim('  Run `mindos start` — it will rebuild automatically.'));
       console.log(`  ${dim('View changelog:')}  ${cyan('https://github.com/GeminiLight/MindOS/releases')}\n`);
     }
+
+    // ── Check if skill rules need updating ──────────────────────────────────
+    try {
+      const updateCfg = JSON.parse(readFileSync(CONFIG_PATH, 'utf-8'));
+      const mindRoot = updateCfg.mindRoot;
+      if (mindRoot && existsSync(mindRoot)) {
+        const isZh = updateCfg.disabledSkills?.includes('mindos');
+        const sName = isZh ? 'mindos-zh' : 'mindos';
+        const lang = isZh ? 'zh' : 'en';
+        const installedRules = resolve(mindRoot, '.agents', 'skills', sName, 'skill-rules.md');
+        const tplRules = resolve(ROOT, 'templates', 'skill-rules', lang, 'skill-rules.md');
+        if (existsSync(installedRules) && existsSync(tplRules)) {
+          const uVer = readFileSync(installedRules, 'utf-8').match(/<!--\s*version:\s*(\S+)\s*-->/)?.[1];
+          const tVer = readFileSync(tplRules, 'utf-8').match(/<!--\s*version:\s*(\S+)\s*-->/)?.[1];
+          if (uVer && tVer && uVer !== tVer) {
+            console.log(`  ${yellow('!')} Skill rules ${dim(uVer)} → ${bold(tVer)} available. Run ${cyan('mindos init-skills --force')} to update ${dim('(user-rules.md preserved)')}\n`);
+          }
+        } else if (!existsSync(resolve(mindRoot, '.agents', 'skills', sName))) {
+          console.log(`  ${dim('Tip:')} Run ${cyan('mindos init-skills')} to enable skill rules in your knowledge base.\n`);
+        }
+      }
+    } catch {}
   },
 
   // ── uninstall ──────────────────────────────────────────────────────────────
@@ -1084,6 +1209,7 @@ ${row('mindos gateway <subcommand>',       'Manage background service (install/u
 ${bold('Config & Diagnostics:')}
 ${row('mindos config <subcommand>',        'View/update config (show/validate/set/unset)')}
 ${row('mindos doctor',                     'Health check (config, ports, build, daemon)')}
+${row('mindos init-skills [--force]',       'Initialize skill rules in knowledge base')}
 ${row('mindos update',                     'Update MindOS to the latest version')}
 ${row('mindos uninstall',                  'Fully uninstall MindOS (stop, remove daemon, npm uninstall)')}
 ${row('mindos logs',                       'Tail service logs (~/.mindos/mindos.log)')}

package/bin/lib/build.js

@@ -4,7 +4,7 @@ import { createHash } from 'node:crypto';
 import { resolve } from 'node:path';
 import { ROOT, BUILD_STAMP, DEPS_STAMP } from './constants.js';
 import { red, dim, yellow } from './colors.js';
-import { run } from './utils.js';
+import { run, npmInstall } from './utils.js';
 
 export function needsBuild() {
   const nextDir = resolve(ROOT, 'app', '.next');
@@ -105,12 +105,7 @@ export function ensureAppDeps() {
     ? 'Updating app dependencies (package-lock.json changed)...\n'
     : 'Installing app dependencies (first run)...\n';
   console.log(yellow(label));
-  try {
-    execSync('npm install --prefer-offline --no-workspaces', { cwd: resolve(ROOT, 'app'), stdio: 'inherit' });
-  } catch {
-    console.log(yellow('Offline install failed, retrying online...\n'));
-    run('npm install --no-workspaces', resolve(ROOT, 'app'));
-  }
+  npmInstall(resolve(ROOT, 'app'), '--no-workspaces');
 
   // Verify critical deps — npm tar extraction can silently fail (ENOENT race)
   if (!verifyDeps()) {

package/bin/lib/mcp-spawn.js

@@ -3,6 +3,7 @@ import { existsSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { ROOT } from './constants.js';
 import { bold, red, yellow } from './colors.js';
+import { npmInstall } from './utils.js';
 
 export function spawnMcp(verbose = false) {
   const mcpPort = process.env.MINDOS_MCP_PORT || '8781';
@@ -11,19 +12,7 @@ export function spawnMcp(verbose = false) {
   const mcpSdk = resolve(ROOT, 'mcp', 'node_modules', '@modelcontextprotocol', 'sdk', 'package.json');
   if (!existsSync(mcpSdk)) {
     console.log(yellow('Installing MCP dependencies (first run)...\n'));
-    const mcpCwd = resolve(ROOT, 'mcp');
-    try {
-      execSync('npm install --prefer-offline --no-workspaces', { cwd: mcpCwd, stdio: 'inherit' });
-    } catch {
-      console.log(yellow('Offline install failed, retrying online...\n'));
-      try {
-        execSync('npm install --no-workspaces', { cwd: mcpCwd, stdio: 'inherit' });
-      } catch (err) {
-        console.error(red('Failed to install MCP dependencies.'));
-        console.error(`  Try manually: cd ${mcpCwd} && npm install\n`);
-        process.exit(1);
-      }
-    }
+    npmInstall(resolve(ROOT, 'mcp'), '--no-workspaces');
   }
   const env = {
     ...process.env,

package/bin/lib/utils.js

@@ -11,6 +11,29 @@ export function run(command, cwd = ROOT) {
   }
 }
 
+/**
+ * Run `npm install` with --prefer-offline for speed, auto-fallback to online
+ * if the local cache is stale or missing a required package version.
+ *
+ * @param {string} cwd - Directory to run in
+ * @param {string} [extraFlags=''] - Additional npm flags (e.g. '--no-workspaces')
+ */
+export function npmInstall(cwd, extraFlags = '') {
+  const base = `npm install ${extraFlags}`.trim();
+  try {
+    execSync(`${base} --prefer-offline`, { cwd, stdio: 'inherit', env: process.env });
+  } catch {
+    // Cache miss or stale packument — retry online
+    try {
+      execSync(base, { cwd, stdio: 'inherit', env: process.env });
+    } catch (err) {
+      console.error(`\nFailed to install dependencies in ${cwd}`);
+      console.error(`  Try manually: cd ${cwd} && ${base}\n`);
+      process.exit(err.status || 1);
+    }
+  }
+}
+
 export function expandHome(p) {
   return p.startsWith('~/') ? resolve(homedir(), p.slice(2)) : p;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geminilight/mindos",
-  "version": "0.5.18",
+  "version": "0.5.20",
   "description": "MindOS — Human-Agent Collaborative Mind System. Local-first knowledge base that syncs your mind to all AI Agents via MCP.",
   "keywords": [
     "mindos",

package/scripts/setup.js

@@ -1205,6 +1205,19 @@ async function main() {
   writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + '\n');
   console.log(`\n${c.green(t('cfgSaved'))}: ${c.dim(CONFIG_PATH)}`);
 
+  // ── Init skill rules in knowledge base ────────────────────────────────────
+  const skillName = selectedTemplate === 'zh' ? 'mindos-zh' : 'mindos';
+  const skillRulesDir = resolve(mindDir, '.agents', 'skills', skillName);
+  if (!existsSync(skillRulesDir)) {
+    const skillRulesLang = selectedTemplate === 'zh' ? 'zh' : 'en';
+    const skillRulesSource = resolve(ROOT, 'templates', 'skill-rules', skillRulesLang);
+    if (existsSync(skillRulesSource)) {
+      mkdirSync(skillRulesDir, { recursive: true });
+      cpSync(skillRulesSource, skillRulesDir, { recursive: true });
+      console.log(`${c.green('✓')} ${c.dim(`Skill rules initialized: ${skillRulesDir}`)}`);
+    }
+  }
+
   // ── Step 7: MCP Agent Install ──────────────────────────────────────────────
   write('\n');
   stepHeader(7);