@geminilight/mindos 0.5.22 → 0.5.23

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

@@ -3,7 +3,7 @@ import path from "path";
 
 const nextConfig: NextConfig = {
   transpilePackages: ['github-slugger'],
-  serverExternalPackages: ['pdfjs-dist', 'pdf-parse', 'chokidar', '@mariozechner/pi-ai', '@mariozechner/pi-agent-core'],
+  serverExternalPackages: ['pdfjs-dist', 'pdf-parse', 'chokidar', 'openai', '@mariozechner/pi-ai', '@mariozechner/pi-agent-core'],
   outputFileTracingRoot: path.join(__dirname),
   turbopack: {
     root: path.join(__dirname),

package/app/package.json

@@ -16,8 +16,8 @@
     "@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",
+    "@mariozechner/pi-agent-core": "^0.61.0",
+    "@mariozechner/pi-ai": "^0.61.0",
     "@sinclair/typebox": "^0.34.33",
     "@tiptap/extension-image": "^3.20.1",
     "@tiptap/extension-link": "^3.20.1",

package/bin/cli.js

@@ -245,7 +245,7 @@ const commands = {
         // Do NOT call start() here — kickstart -k would kill the just-started process,
         // causing a port-conflict race condition with KeepAlive restart loops.
         console.log(dim('  (First run may take a few minutes to install dependencies and build the app.)'));
-        const ready = await waitForHttp(Number(webPort), { retries: 60, intervalMs: 2000, label: 'Web UI', logFile: LOG_PATH });
+        const ready = await waitForHttp(Number(webPort), { retries: 120, intervalMs: 2000, label: 'Web UI', logFile: LOG_PATH });
         if (!ready) {
           console.error(red('\n✘ Service started but Web UI did not become ready in time.'));
           console.error(dim('  Check logs with: mindos logs\n'));
@@ -271,36 +271,22 @@ 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) ──────────────────
+    // ── Auto-migrate user-rules.md to root user-skill-rules.md ─────────────
     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')}`);
+        const rootUserRules = resolve(mr, 'user-skill-rules.md');
+
+        // Migrate: .agents/skills/{name}/user-rules.md → {mindRoot}/user-skill-rules.md
+        if (!existsSync(rootUserRules)) {
+          const oldUserRules = resolve(sDir, 'user-rules.md');
+          if (existsSync(oldUserRules)) {
+            cpSync(oldUserRules, rootUserRules);
+            console.log(`  ${green('✓')} ${dim('Migrated user-rules.md → user-skill-rules.md')}`);
           }
         }
       }
@@ -440,7 +426,6 @@ ${dim('Shortcut: mindos start --daemon  →  install + start in one step')}
 
   // ── init-skills ──────────────────────────────────────────────────────────
   'init-skills': async () => {
-    const force = process.argv.includes('--force');
     console.log(`\n${bold('📦 Initialize Skill Rules')}\n`);
 
     if (!existsSync(CONFIG_PATH)) {
@@ -460,56 +445,23 @@ ${dim('Shortcut: mindos start --daemon  →  install + start in one step')}
       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`);
+    // Skill operating rules are now built into SKILL.md (shipped with the app).
+    // This command only initializes user-skill-rules.md for personalization.
+    const dest = resolve(mindRoot, 'user-skill-rules.md');
+    if (existsSync(dest)) {
+      console.log(`  ${dim('skip')}  user-skill-rules.md (already exists)\n`);
     } else {
-      console.log(`\n  ${green('✔')} Skill rules initialized at ${dim(skillDir)}\n`);
+      const isZh = config.disabledSkills?.includes('mindos');
+      const lang = isZh ? 'zh' : 'en';
+      const src = resolve(ROOT, 'templates', 'skill-rules', lang, 'user-rules.md');
+      if (existsSync(src)) {
+        cpSync(src, dest);
+        console.log(`  ${green('✓')}  user-skill-rules.md created at ${dim(mindRoot)}\n`);
+      } else {
+        console.log(`  ${dim('skip')}  Template not found, create user-skill-rules.md manually if needed.\n`);
+      }
     }
+    console.log(`  ${dim('Note: Operating rules are now built into the app. No install needed.')}\n`);
   },
 
   // ── doctor ─────────────────────────────────────────────────────────────────
@@ -727,7 +679,7 @@ ${dim('Shortcut: mindos start --daemon  →  install + start in one step')}
       const webPort = updateConfig.port ?? 3456;
       const mcpPort = updateConfig.mcpPort ?? 8781;
       console.log(dim('  (Waiting for Web UI to come back up — first run after update includes a rebuild...)'));
-      const ready = await waitForHttp(Number(webPort), { retries: 60, intervalMs: 2000, label: 'Web UI', logFile: LOG_PATH });
+      const ready = await waitForHttp(Number(webPort), { retries: 120, intervalMs: 2000, label: 'Web UI', logFile: LOG_PATH });
       if (ready) {
         const localIP = getLocalIP();
         console.log(`\n${'─'.repeat(53)}`);
@@ -746,28 +698,6 @@ ${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 ──────────────────────────────────────────────────────────────
@@ -1212,7 +1142,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 init-skills',                 'Create user-skill-rules.md for personalization')}
 ${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.22",
+  "version": "0.5.23",
   "description": "MindOS — Human-Agent Collaborative Mind System. Local-first knowledge base that syncs your mind to all AI Agents via MCP.",
   "keywords": [
     "mindos",
@@ -57,7 +57,9 @@
     "!assets/images",
     "!mcp/node_modules",
     "!mcp/dist",
-    "!mcp/package-lock.json"
+    "!mcp/package-lock.json",
+    "!mcp/*.tgz",
+    "!app/package-lock.json"
   ],
   "scripts": {
     "setup": "node scripts/setup.js",

package/scripts/setup.js

@@ -1205,18 +1205,8 @@ 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}`)}`);
-    }
-  }
+  // ── Skill rules are now built into SKILL.md — no install needed ──────────
+  // user-skill-rules.md will be created on first preference capture or via `mindos init-skills`.
 
   // ── Step 7: MCP Agent Install ──────────────────────────────────────────────
   write('\n');

package/skills/mindos/SKILL.md

@@ -14,13 +14,231 @@ description: >
 
 # MindOS Skill
 
-Load operating rules from the knowledge base, then execute the user's task.
+Execute the user's task following the rules below.
+User personalization rules (`user-skill-rules.md`) are included in bootstrap
+context automatically when present. User rules override default rules on conflict.
 
-## Protocol
+---
+
+<!-- version: 1.0.0 -->
+# MindOS Operating Rules
+
+## Core Principles
+
+- 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 must trigger an automatic check and update of the README in that directory and its parent directory.
+
+## 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. 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.
+  4. Try alternative search terms (synonyms, broader/narrower keywords, English/Chinese variants) as a parallel strategy.
+
+## 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 high-impact actions (bulk deletion, large-scale rename/move, broad directory restructuring, 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.
+- 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.
+
+## Preference Capture
+
+When the user expresses a preference correction during operations (e.g., "don't do X in the future", "next time remember to...", "this should go in... not in..."), append it as a structured rule to `user-skill-rules.md` in the knowledge base root under the appropriate section. Confirm to the user: "Preference recorded."
+
+---
+
+# 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.
+
+## 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.
+
+---
+
+# Post-Task Hooks
+
+After completing a task, check the conditions below. If one matches, make a one-line proposal to the user. If none match, end quietly.
+
+## Discipline
+
+1. Do not propose after simple operations (rename, append one line, read-only queries).
+2. At most 1 proposal per task — pick the highest priority match.
+3. One sentence + specific target file/path. Only expand if the user says yes.
+4. Check user-skill-rules.md suppression section first — skip any suppressed hook.
+
+## Default Hooks
+
+### Experience capture (priority: high)
+- Condition: task involved debugging, troubleshooting, or took multiple rounds to resolve.
+- Propose: "Record this experience to {related experience file}?"
+- Format: problem -> cause -> solution -> rule
+
+### Consistency sync (priority: high)
+- Condition: edited file A, and A is referenced by other files (check via `get_backlinks`).
+- Propose: "{B} references what you just changed — sync it?"
+
+### Linked update (priority: medium)
+- Condition: changed a CSV/TODO item status, and related docs exist.
+- Propose: "Sync the corresponding info in {related doc}?"
+
+### Structure classification (priority: medium)
+- Condition: created a new file in a temporary location or inbox.
+- Propose: "Move this to {recommended directory}?"
+
+### Pattern extraction (priority: low)
+- Condition: 3+ structurally similar operations in the current session.
+- Propose: "This operation repeated multiple times — create an SOP?"
+
+### Conversation retrospective (priority: low)
+- Condition: session >10 turns and involved decisions, trade-offs, or lessons.
+- Propose: "This conversation had some decisions worth capturing — do a retrospective?"
+
+## User-defined Hooks
 
-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.
+<!-- Add your own hooks below, following the same format. -->
+<!-- Example:
+### Weekly report material (priority: medium)
+- Condition: updated a Project-related file.
+- Propose: "Record this change in the weekly report?"
+-->