@geminilight/mindos 0.5.19 → 0.5.21

package/app/package.json

@@ -11,13 +11,14 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "@ai-sdk/anthropic": "^3.0.58",
-    "@ai-sdk/openai": "^3.0.41",
     "@base-ui/react": "^1.2.0",
     "@codemirror/lang-markdown": "^6.5.0",
     "@codemirror/state": "^6.5.4",
     "@codemirror/theme-one-dark": "^6.1.3",
     "@codemirror/view": "^6.39.16",
+    "@mariozechner/pi-agent-core": "^0.60.0",
+    "@mariozechner/pi-ai": "^0.60.0",
+    "@sinclair/typebox": "^0.34.33",
     "@tiptap/extension-image": "^3.20.1",
     "@tiptap/extension-link": "^3.20.1",
     "@tiptap/extension-placeholder": "^3.20.1",
@@ -30,7 +31,6 @@
     "@tiptap/react": "^3.20.1",
     "@tiptap/starter-kit": "^3.20.1",
     "@xyflow/react": "^12.10.1",
-    "ai": "^6.0.116",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
     "codemirror": "^6.0.2",
@@ -41,6 +41,7 @@
     "papaparse": "^5.5.3",
     "pdf-parse": "^2.4.5",
     "pdfjs-dist": "^4.10.38",
+    "picocolors": "^1.1.1",
     "react": "19.2.3",
     "react-dom": "19.2.3",
     "react-markdown": "^10.1.0",
@@ -48,6 +49,7 @@
     "rehype-raw": "^7.0.0",
     "rehype-slug": "^6.0.0",
     "remark-gfm": "^4.0.1",
+    "source-map-js": "^1.2.1",
     "tailwind-merge": "^3.5.0",
     "tiptap-markdown": "^0.9.0",
     "tw-animate-css": "^1.4.0",
@@ -59,6 +61,7 @@
     "@types/papaparse": "^5.5.2",
     "@types/react": "^19",
     "@types/react-dom": "^19",
+    "@vitest/coverage-v8": "^4.1.0",
     "eslint": "^9",
     "eslint-config-next": "16.1.6",
     "playwright": "^1.58.2",

package/bin/cli.js

@@ -39,12 +39,15 @@
  */
 
 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';
+
+// Resolve the local next binary to avoid npx pulling a mismatched global version
+const NEXT_BIN = resolve(ROOT, 'app', 'node_modules', '.bin', 'next');
 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';
@@ -214,7 +217,7 @@ const commands = {
       startSyncDaemon(devMindRoot).catch(() => {});
     }
     await printStartupInfo(webPort, mcpPort);
-    run(`npx next dev -p ${webPort} ${extra}`, resolve(ROOT, 'app'));
+    run(`${NEXT_BIN} dev -p ${webPort} ${extra}`, resolve(ROOT, 'app'));
   },
 
   // ── start ──────────────────────────────────────────────────────────────────
@@ -268,6 +271,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.
@@ -292,7 +330,7 @@ const commands = {
       console.log(yellow('Building MindOS (first run or new version detected)...\n'));
       cleanNextDir();
       run('node scripts/gen-renderer-index.js', ROOT);
-      run('npx next build', resolve(ROOT, 'app'));
+      run(`${NEXT_BIN} build`, resolve(ROOT, 'app'));
       writeBuildStamp();
     }
     const mcp = spawnMcp(isVerbose);
@@ -304,7 +342,7 @@ const commands = {
       startSyncDaemon(mindRoot).catch(() => {});
     }
     await printStartupInfo(webPort, mcpPort);
-    run(`npx next start -p ${webPort} ${extra}`, resolve(ROOT, 'app'));
+    run(`${NEXT_BIN} start -p ${webPort} ${extra}`, resolve(ROOT, 'app'));
   },
 
   // ── build ──────────────────────────────────────────────────────────────────
@@ -312,7 +350,7 @@ const commands = {
     ensureAppDeps();
     cleanNextDir();
     run('node scripts/gen-renderer-index.js', ROOT);
-    run(`npx next build ${extra}`, resolve(ROOT, 'app'));
+    run(`${NEXT_BIN} build ${extra}`, resolve(ROOT, 'app'));
     writeBuildStamp();
   },
 
@@ -400,6 +438,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}`);
@@ -634,6 +746,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 ──────────────────────────────────────────────────────────────
@@ -1078,6 +1212,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geminilight/mindos",
-  "version": "0.5.19",
+  "version": "0.5.21",
   "description": "MindOS — Human-Agent Collaborative Mind System. Local-first knowledge base that syncs your mind to all AI Agents via MCP.",
   "keywords": [
     "mindos",
@@ -73,5 +73,8 @@
   },
   "dependencies": {
     "chokidar": "^5.0.0"
+  },
+  "devDependencies": {
+    "source-map-js": "^1.2.1"
   }
 }

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);

package/skills/mindos/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: mindos
 description: >
-  MindOS knowledge base operation guide, only for agent tasks on files inside the MindOS knowledge base (mindRoot path).
+  MindOS knowledge base operation guide, only for agent tasks on files inside the MindOS knowledge base.
   Trigger only when the target files are inside the MindOS knowledge base directory.
   Typical requests: "update notes", "search knowledge base", "organize files", "execute SOP",
   "review with our standards", "handoff to another agent", "sync decisions", "append CSV",
@@ -12,173 +12,15 @@ description: >
   or the task involves modifying project source code or project documentation.
 ---
 
-# MindOS Knowledge Base Operation Guide
+# MindOS Skill
 
-Use this skill to operate safely and consistently in a MindOS-style local knowledge base.
+Load operating rules from the knowledge base, then execute the user's task.
 
-## Core Principles
+## Protocol
 
-- Treat repository state as source of truth.
-- **The directory tree loaded at bootstrap is a first-class semantic asset.** Directory names, file names, and their hierarchy encode what the user has stored and how they organize their thinking. Always reason from this structure before resorting to search — it often tells you where content lives without any tool call.
-- Read before write.
-- Prefer minimal, precise edits.
-- Keep changes auditable and easy to review.
-
-## Startup Protocol
-
-Run this sequence before substantive edits:
-
-1. Load root guidance.
-- Prefer `mindos_bootstrap`.
-- If unavailable, read root `INSTRUCTION.md` and root `README.md` directly.
-
-2. Discover current structure dynamically.
-- Use `mindos_list_files` and targeted `mindos_search_notes`.
-- Do not assume fixed top-level directory names.
-
-3. Load local guidance around target paths.
-- Read nearby `README.md` / `INSTRUCTION.md` when present.
-- Follow local conventions over global assumptions.
-
-4. Execute edits.
-
-If required context is missing, continue with best effort and state assumptions explicitly.
-
-## Dynamic Structure Rules
-
-- Do not hardcode a canonical directory tree.
-- Infer conventions from neighboring files before creating or rewriting content.
-- Mirror existing local patterns for naming, heading structure, CSV schema, and references.
-- For new files, follow sibling style rather than inventing a new standard.
-- **Never create files or directories in the root directory unless the user explicitly requests it.** The root is reserved for top-level governance files (README, INSTRUCTION, CONFIG). New content should be placed under the most semantically appropriate existing subdirectory. Reason from the directory tree in context to find the right home.
-- When creating a new file or directory, always determine the best parent directory first by reviewing the existing structure. If no existing directory is a clear fit, propose 1-2 candidate locations and ask the user before creating.
-- **After any file create/delete/move/rename, always sync affected README files.** READMEs serve as directory indexes and navigation entry points. Any operation that changes a directory's contents (creating, deleting, moving, or renaming files or subdirectories) must trigger an automatic check and update of the README in that directory and its parent directory, so they accurately reflect the current structure. This requires no user prompting — it is basic structural consistency discipline.
-
-## Pre-Write Checklist
-
-Before any non-trivial write, confirm all checks:
-
-1. Target file/path is confirmed and exists or should be created.
-2. **Target location is under an appropriate subdirectory, not the root.** If unsure which directory fits best, propose candidates and ask the user.
-3. Current content has been read, or absence is explicitly confirmed.
-4. Local governance docs near the target path are considered.
-5. Edit scope is minimal and aligned with user intent.
-6. Reference/backlink impact is evaluated for path changes.
-
-## Tool Selection Guide
-
-### Discovery
-
-- `mindos_bootstrap`: Load startup context.
-- `mindos_list_files`: Inspect file tree.
-- `mindos_search_notes`: Locate relevant files by keyword/scope/type/date. **When searching, always issue multiple parallel searches with different keywords upfront** — synonyms, abbreviations, English/Chinese variants, and broader/narrower terms. A single keyword is fragile; casting a wider net on the first try avoids wasted rounds.
-- `mindos_get_recent`: Inspect latest activity.
-- `mindos_get_backlinks`: Assess impact before rename/move/delete.
-
-### Read and write
-
-- `mindos_read_file`: Read file content.
-- `mindos_write_file`: Use only for true full replacement.
-- `mindos_create_file`: Create `.md`/`.csv` files.
-- `mindos_delete_file`: Delete only with explicit user intent.
-- `mindos_rename_file`, `mindos_move_file`: Structural edits with follow-up reference checks.
-
-### Precise editing
-
-- `mindos_read_lines`: Locate exact lines.
-- `mindos_insert_lines`: Insert at index.
-- `mindos_update_lines`: Replace specific range.
-- `mindos_append_to_file`: Append to end.
-- `mindos_insert_after_heading`: Insert under heading.
-- `mindos_update_section`: Replace one markdown section.
-
-### History and tables
-
-- `mindos_get_history`, `mindos_get_file_at_version`: Investigate/recover history.
-- `mindos_append_csv`: Append validated row after header check.
-
-## Fallback Rules
-
-- If some `mindos_*` tools are unavailable, use equivalent available tools while preserving the same safety discipline.
-- If `mindos_bootstrap` is unavailable, do manual startup reads.
-- If line/section edit tools are unavailable, emulate minimal edits through read plus constrained rewrite.
-- If `mindos_search_notes` returns no results, do not give up. The directory tree loaded at bootstrap is already in your context — directory names, file names, and their hierarchy are semantically rich and often enough to infer where content lives. Escalate progressively:
-  1. Review the directory structure already in context. Reason about which directories and files are likely relevant based on naming, hierarchy, and topic proximity.
-  2. Read the most promising candidate files directly to confirm relevance.
-  3. If candidates are unclear, use `mindos_list_files` on a specific subdirectory for finer-grained structure not captured at bootstrap.
-  4. Try alternative search terms (synonyms, broader/narrower keywords, English/Chinese variants) as a parallel strategy.
-
-## Execution Patterns
-
-Select the matching pattern below. All patterns share a common discipline: search → read → minimal edit → verify → summarize.
-
-### Core patterns (high-frequency)
-
-#### Capture or update notes
-Search → read target + local rules → apply minimal edit → keep references consistent.
-
-#### Context-aware question answering
-Reason from directory tree → read relevant files → answer grounded in stored content with file citations → if info is missing, say so explicitly.
-
-#### Structure-aware multi-file routing
-For unstructured inputs (meeting notes, braindumps, chat exports) that belong in multiple places:
-1. Parse input into semantic units (facts, decisions, action items, ideas).
-2. For each unit, search + read candidate destination files.
-3. **Present routing plan to user for approval** (table: what → which file → where).
-4. Apply minimal edits. Create new files only when no existing file fits.
-5. Summarize all changes for audit.
-
-#### Conversation retrospective
-1. Confirm scope with user.
-2. Extract reusable artifacts: decisions, rationale, pitfalls, next actions.
-3. Route each to the best existing file (or create near related docs).
-4. Add trace note of what changed and why. Ask user when routing confidence is low.
-
-### Structural change patterns (always apply after file create/delete/move/rename)
-
-- **Rename/move**: `get_backlinks` → report impact → confirm → execute → update all references → verify no orphans.
-- **Auto-sync READMEs**: After any structural change, update README in affected directories + parent directories to reflect current contents. This is automatic — no separate user request needed.
-
-### Reference patterns (use when task matches)
-
-| Pattern | Key steps |
-|---------|-----------|
-| CSV operations | Read header → validate fields → append row |
-| TODO/task management | Locate list → read format → minimal edit preserving conventions |
-| SOP/workflow execution | Read doc fully → execute stepwise → update only affected section |
-| Cross-agent handoff | Read task state + decisions → continue without re-discovery → write back progress |
-| Knowledge conflict resolution | Multi-term search for old info → list all affected files → present change plan → update after approval |
-| Distill experience into SOP | Extract procedure → generalize → create under Workflows/ with prerequisites, steps, pitfalls |
-| Periodic review/summary | `get_recent`/`get_history` → read changed files → categorize → structured summary |
-| Handoff document synthesis | Identify sources → read → synthesize (background, decisions, status, open items) → place in project dir |
-| Relationship management | Extract updates from notes → update contact records → generate next-step strategy |
-| Information collection | Locate sources → read outreach docs → personalize per target → write back outcomes |
-| Project bootstrap | Read preference/stack docs → scaffold aligned with standards → record decisions |
-| Code review | Read review standards → check naming/security/performance → output actionable findings |
-| Distill cross-agent discussion | Confirm decisions with user → structure as problem/decision/rationale/next-actions → minimal write-back |
-
-## Interaction Rules
-
-- **When a request is ambiguous or too broad (e.g., "help me organize things"), always ask for clarification before acting.** Propose specific options based on what you see in the knowledge base (recent changes, directory structure), but do not start reorganizing or rewriting without understanding the user's intent and scope.
-- When presenting search results or options, prioritize brevity and relevance. Show the most likely match first.
-- When answering questions from stored knowledge, always cite the source file path so the user can verify.
-
-## Safety Rules
-
-- By default, treat root `INSTRUCTION.md`, root `README.md`, and any directory-level `INSTRUCTION.md` governance docs as high-sensitivity; ask for confirmation before modifying them.
-- Ask before editing high-sensitivity governance files.
-- Ask before high-impact actions.
-- High-impact actions include bulk deletion, large-scale rename/move, broad directory restructuring, and cross-file mass rewrites.
-- **When an operation will touch multiple files, always present the full change plan to the user first.** List each target file, what will change, and why. Wait for approval before executing. This is non-negotiable — users must be able to see and control multi-file updates before they happen.
-- Never store secrets, tokens, or passwords.
-- Never delete or rewrite outside user intent.
-
-## Quality Gates
-
-Before finishing any operation, verify:
-
-1. Result directly answers user intent.
-2. Updated content matches local style and structure.
-3. References/links remain valid after structural edits.
-4. No sensitive information was introduced.
-5. Summary to user is specific enough for quick audit.
+1. Read `.agents/skills/mindos/skill-rules.md` — operating rules.
+   - If not found: fall back to `mindos_bootstrap` (or read root INSTRUCTION.md
+     + README.md). Inform user: "Run `mindos init-skills` for full skill rules."
+2. If `.agents/skills/mindos/user-rules.md` exists and is non-empty:
+   read it. User rules override default rules on conflict.
+3. Execute task following loaded rules. After completion, evaluate proactive hooks.