openmatrix 0.1.18 → 0.1.20

package/dist/cli/commands/check-gitignore.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const checkGitignoreCommand: Command;

package/dist/cli/commands/check-gitignore.js

@@ -0,0 +1,361 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkGitignoreCommand = void 0;
+// src/cli/commands/check-gitignore.ts
+const commander_1 = require("commander");
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+/**
+ * 项目类型对应的 gitignore 条目
+ */
+const GITIGNORE_TEMPLATES = {
+    nodejs: [
+        'node_modules/',
+        'dist/',
+        'build/',
+        '.npm/',
+        '*.log',
+        'npm-debug.log*',
+        'yarn-debug.log*',
+        'yarn-error.log*'
+    ],
+    typescript: [
+        '*.tsbuildinfo',
+        '.tsbuildinfo'
+    ],
+    python: [
+        '__pycache__/',
+        '*.py[cod]',
+        '*$py.class',
+        '.venv/',
+        'venv/',
+        'ENV/',
+        '.pytest_cache/',
+        '.mypy_cache/',
+        '*.egg-info/',
+        'dist/',
+        'build/'
+    ],
+    java: [
+        'target/',
+        '.gradle/',
+        'build/',
+        '*.class',
+        '*.jar',
+        '*.war'
+    ],
+    go: [
+        'vendor/',
+        'bin/',
+        '*.exe',
+        '*.exe~',
+        '*.dll',
+        '*.so',
+        '*.dylib'
+    ],
+    rust: [
+        'target/',
+        'Cargo.lock'
+    ],
+    dotnet: [
+        'bin/',
+        'obj/',
+        '*.nupkg',
+        '*.snupkg'
+    ],
+    php: [
+        'vendor/',
+        'composer.lock'
+    ],
+    dart: [
+        '.dart_tool/',
+        '.packages',
+        'build/',
+        '.pub/',
+        'pubspec.lock'
+    ],
+    common: [
+        '.env',
+        '.env.local',
+        '.env.*.local',
+        '.DS_Store',
+        'Thumbs.db',
+        '*.swp',
+        '*.swo',
+        '*~',
+        '.idea/',
+        '.vscode/',
+        '*.iml'
+    ]
+};
+/**
+ * 根据项目类型检测需要的 gitignore 条目
+ */
+async function detectProjectType(projectRoot) {
+    const types = [];
+    // 检查 package.json
+    try {
+        const packageJsonPath = path.join(projectRoot, 'package.json');
+        const content = await fs.readFile(packageJsonPath, 'utf-8');
+        const pkg = JSON.parse(content);
+        types.push('nodejs');
+        // 检查 TypeScript
+        if (pkg.devDependencies?.typescript || pkg.dependencies?.typescript) {
+            types.push('typescript');
+        }
+    }
+    catch {
+        // 不是 Node.js 项目
+    }
+    // 检查 Python
+    try {
+        await fs.access(path.join(projectRoot, 'pyproject.toml'));
+        types.push('python');
+    }
+    catch { }
+    try {
+        await fs.access(path.join(projectRoot, 'requirements.txt'));
+        if (!types.includes('python'))
+            types.push('python');
+    }
+    catch { }
+    // 检查 Java
+    try {
+        await fs.access(path.join(projectRoot, 'pom.xml'));
+        types.push('java');
+    }
+    catch { }
+    try {
+        await fs.access(path.join(projectRoot, 'build.gradle'));
+        if (!types.includes('java'))
+            types.push('java');
+    }
+    catch { }
+    // 检查 Go
+    try {
+        await fs.access(path.join(projectRoot, 'go.mod'));
+        types.push('go');
+    }
+    catch { }
+    // 检查 Rust
+    try {
+        await fs.access(path.join(projectRoot, 'Cargo.toml'));
+        types.push('rust');
+    }
+    catch { }
+    // 检查 .NET
+    try {
+        const files = await fs.readdir(projectRoot);
+        if (files.some(f => f.endsWith('.sln') || f.endsWith('.csproj'))) {
+            types.push('dotnet');
+        }
+    }
+    catch { }
+    // 检查 PHP
+    try {
+        await fs.access(path.join(projectRoot, 'composer.json'));
+        types.push('php');
+    }
+    catch { }
+    // 检查 Dart
+    try {
+        await fs.access(path.join(projectRoot, 'pubspec.yaml'));
+        types.push('dart');
+    }
+    catch { }
+    // 始终添加通用条目
+    types.push('common');
+    return types;
+}
+/**
+ * 获取所有需要的 gitignore 条目
+ */
+function getRequiredEntries(projectTypes) {
+    const entries = new Set();
+    for (const type of projectTypes) {
+        const template = GITIGNORE_TEMPLATES[type];
+        if (template) {
+            for (const entry of template) {
+                entries.add(entry);
+            }
+        }
+    }
+    return entries;
+}
+/**
+ * 解析现有 gitignore 内容
+ */
+function parseGitignore(content) {
+    const entries = new Set();
+    const lines = content.split('\n');
+    for (const line of lines) {
+        const trimmed = line.trim();
+        // 跳过注释和空行
+        if (trimmed && !trimmed.startsWith('#')) {
+            entries.add(trimmed);
+        }
+    }
+    return entries;
+}
+exports.checkGitignoreCommand = new commander_1.Command('check-gitignore')
+    .description('检查并自动补充 .gitignore 文件')
+    .option('--json', '输出 JSON 格式')
+    .option('--dry-run', '仅显示会添加的内容，不实际修改')
+    .action(async (options) => {
+    const projectRoot = process.cwd();
+    const gitignorePath = path.join(projectRoot, '.gitignore');
+    try {
+        // 检测项目类型
+        const projectTypes = await detectProjectType(projectRoot);
+        const requiredEntries = getRequiredEntries(projectTypes);
+        // 读取现有 gitignore
+        let existingEntries = new Set();
+        let exists = false;
+        try {
+            const content = await fs.readFile(gitignorePath, 'utf-8');
+            existingEntries = parseGitignore(content);
+            exists = true;
+        }
+        catch {
+            // 文件不存在
+        }
+        // 计算缺失的条目
+        const missingEntries = [];
+        for (const entry of requiredEntries) {
+            if (!existingEntries.has(entry)) {
+                missingEntries.push(entry);
+            }
+        }
+        // JSON 输出
+        if (options.json) {
+            console.log(JSON.stringify({
+                exists,
+                projectTypes,
+                missingEntries,
+                totalRequired: requiredEntries.size,
+                totalExisting: existingEntries.size
+            }, null, 2));
+            return;
+        }
+        // 没有缺失条目
+        if (missingEntries.length === 0) {
+            console.log(chalk_1.default.green('✅ .gitignore 已完善，无需修改\n'));
+            return;
+        }
+        // Dry run 模式
+        if (options.dryRun) {
+            console.log(chalk_1.default.cyan('🔍 检测到以下缺失条目:\n'));
+            for (const entry of missingEntries) {
+                console.log(chalk_1.default.gray(`  + ${entry}`));
+            }
+            return;
+        }
+        // 自动补充
+        const newContent = generateGitignoreContent(missingEntries);
+        if (exists) {
+            // 追加到现有文件
+            await fs.appendFile(gitignorePath, `\n${newContent}`);
+            console.log(chalk_1.default.green(`✅ 已向 .gitignore 添加 ${missingEntries.length} 个条目:\n`));
+        }
+        else {
+            // 创建新文件
+            await fs.writeFile(gitignorePath, newContent);
+            console.log(chalk_1.default.green(`✅ 已创建 .gitignore，包含 ${missingEntries.length} 个条目:\n`));
+        }
+        for (const entry of missingEntries) {
+            console.log(chalk_1.default.gray(`  + ${entry}`));
+        }
+        console.log();
+    }
+    catch (error) {
+        if (options.json) {
+            console.log(JSON.stringify({ error: String(error) }));
+        }
+        else {
+            console.error(chalk_1.default.red('❌ 检查失败:'), error);
+        }
+        process.exit(1);
+    }
+});
+/**
+ * 生成 gitignore 内容
+ */
+function generateGitignoreContent(entries) {
+    const timestamp = new Date().toISOString().split('T')[0];
+    // 按类型分组
+    const groups = {
+        'Dependencies': [],
+        'Build': [],
+        'Environment': [],
+        'IDE': [],
+        'OS': [],
+        'Other': []
+    };
+    for (const entry of entries) {
+        if (entry.includes('node_modules') || entry.includes('vendor') || entry.includes('.venv')) {
+            groups['Dependencies'].push(entry);
+        }
+        else if (entry.includes('dist') || entry.includes('build') || entry.includes('target')) {
+            groups['Build'].push(entry);
+        }
+        else if (entry.includes('.env')) {
+            groups['Environment'].push(entry);
+        }
+        else if (entry.includes('.idea') || entry.includes('.vscode') || entry.includes('.iml')) {
+            groups['IDE'].push(entry);
+        }
+        else if (entry.includes('.DS_Store') || entry.includes('Thumbs.db')) {
+            groups['OS'].push(entry);
+        }
+        else {
+            groups['Other'].push(entry);
+        }
+    }
+    let content = `\n# Auto-generated by OpenMatrix (${timestamp})\n`;
+    for (const [group, items] of Object.entries(groups)) {
+        if (items.length > 0) {
+            content += `\n# ${group}\n`;
+            for (const item of items) {
+                content += `${item}\n`;
+            }
+        }
+    }
+    return content;
+}

package/dist/cli/commands/check.js

@@ -50,7 +50,7 @@ exports.checkCommand = new commander_1.Command('check')
     .option('--categories <items>', '指定检测类别 (逗号分隔)', 'bug,quality,capability,ux,style,security,common')
     .option('--min-priority <level>', '最小优先级 (critical|high|medium|low)', 'low')
     .option('--max <number>', '最大建议数量', '50')
-    .option('--scan <dirs>', '扫描目录 (逗号分隔)', 'src,skills,tests,docs')
+    .option('--scan <dirs>', '扫描目录 (逗号分隔)', 'src,skills,docs')
     .option('--interactive', '交互式选择要执行的改进', false)
     .action(async (hint, options) => {
     const projectRoot = process.cwd();

package/dist/cli/index.js

@@ -12,6 +12,7 @@ const meeting_js_1 = require("./commands/meeting.js");
 const auto_js_1 = require("./commands/auto.js");
 const install_skills_js_1 = require("./commands/install-skills.js");
 const check_js_1 = require("./commands/check.js");
+const check_gitignore_js_1 = require("./commands/check-gitignore.js");
 const analyze_js_1 = require("./commands/analyze.js");
 const program = new commander_1.Command();
 program
@@ -29,6 +30,7 @@ program.addCommand(meeting_js_1.meetingCommand);
 program.addCommand(auto_js_1.autoCommand);
 program.addCommand(install_skills_js_1.installSkillsCommand);
 program.addCommand(check_js_1.checkCommand);
+program.addCommand(check_gitignore_js_1.checkGitignoreCommand);
 program.addCommand(analyze_js_1.analyzeCommand);
 // 默认帮助
 program.parse();

package/dist/orchestrator/phase-executor.js

@@ -445,8 +445,11 @@ npm test -- --coverage 2>/dev/null || npm run test:coverage 2>/dev/null || echo
 
 ### 4. Lint 检查
 \`\`\`bash
-npm run lint || echo "No lint script configured"
+# 先检查是否有 lint 脚本
+npm run lint 2>&1 || echo "EXIT_CODE: $?"
 \`\`\`
+**重要**: 如果 lint 命令返回非零退出码且有 errors，必须报告为 VERIFY_FAILED。
+如果项目没有 lint 脚本（显示 "missing script"），标记为 ⏭️ Skipped。
 **要求**: ${qc.strictLint ? '无 error' : '无严重 error'}
 **失败后果**: ${qc.strictLint ? '❌ VERIFY_FAILED' : '⚠️ 警告'}
 
@@ -562,6 +565,12 @@ Fix Required:
 - **不要伪造通过结果**
 - 如果项目没有某个脚本，标记为 "⏭️ Skipped" 而非 "❌ Failed"
 - 所有检查结果必须基于实际命令输出
+
+## 🔧 配置检查 (可选但推荐)
+检查以下常见配置问题:
+- **Vitest 配置**: 如果存在 \`e2e/\` 目录，确保 \`vite.config.ts\` 的 \`test.exclude\` 包含 \`e2e\`
+- **测试框架冲突**: 确保 Vitest 不运行 Playwright/Cypress 测试文件
+- 如果发现配置问题，记录到报告中但不要阻止通过
 `);
         return parts.join('\n');
     }
@@ -805,13 +814,32 @@ ACCEPT_FAILED
         // 解析构建结果
         result.build.success = output.includes('VERIFY_PASSED') ||
             (output.includes('npm run build') && !output.includes('error'));
-        // 解析 Lint 结果
-        const lintErrorMatch = output.match(/(\d+)\s*error/i);
-        if (lintErrorMatch)
-            result.lint.errors = parseInt(lintErrorMatch[1], 10);
-        const lintWarnMatch = output.match(/(\d+)\s*warning/i);
-        if (lintWarnMatch)
-            result.lint.warnings = parseInt(lintWarnMatch[1], 10);
+        // 解析 Lint 结果 - 支持多种 ESLint 输出格式
+        // 格式1: "✖ 137 problems (92 errors, 45 warnings)"
+        const detailedMatch = output.match(/✖\s*\d+\s*problems?\s*\((\d+)\s*errors?,\s*(\d+)\s*warnings?\)/i);
+        if (detailedMatch) {
+            result.lint.errors = parseInt(detailedMatch[1], 10);
+            result.lint.warnings = parseInt(detailedMatch[2], 10);
+        }
+        else {
+            // 格式2: "X errors" 和 "Y warnings"
+            const lintErrorMatch = output.match(/(\d+)\s*error/i);
+            if (lintErrorMatch)
+                result.lint.errors = parseInt(lintErrorMatch[1], 10);
+            const lintWarnMatch = output.match(/(\d+)\s*warning/i);
+            if (lintWarnMatch)
+                result.lint.warnings = parseInt(lintWarnMatch[1], 10);
+        }
+        // 检测 Lint 是否实际执行并失败
+        // ESLint 退出码非0时，输出中会包含 "✖" 或 "problems"
+        const lintFailed = output.includes('✖') && output.includes('problems');
+        if (lintFailed && result.lint.errors === 0) {
+            // 尝试从问题总数中推断
+            const problemsMatch = output.match(/✖\s*(\d+)\s*problems?/i);
+            if (problemsMatch) {
+                result.lint.errors = parseInt(problemsMatch[1], 10);
+            }
+        }
         // 解析安全漏洞
         const vulnMatch = output.match(/(\d+)\s*(?:vulnerabilities|vulnerable)/i);
         if (vulnMatch)

package/dist/orchestrator/upgrade-detector.js

@@ -41,8 +41,8 @@ const path = __importStar(require("path"));
  * 默认配置
  */
 exports.DEFAULT_DETECTOR_CONFIG = {
-    scanDirs: ['src', 'skills', 'tests', 'docs', 'prompts', '.claude', '.cursor'],
-    excludeDirs: ['node_modules', 'dist', '.git', '.openmatrix'],
+    scanDirs: ['src', 'skills', 'docs', 'prompts', '.claude', '.cursor'],
+    excludeDirs: ['node_modules', 'dist', '.git', '.openmatrix', 'tests'],
     categories: ['bug', 'quality', 'capability', 'ux', 'style', 'security', 'common', 'prompt', 'skill', 'agent'],
     minPriority: 'low'
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openmatrix",
-  "version": "0.1.18",
+  "version": "0.1.20",
   "description": "AI Agent task orchestration system with Claude Code Skills integration",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/skills/check.md

@@ -106,9 +106,7 @@ description: 自动检测项目可改进点并提供升级建议，用户确认
 
    ---
 
-   ## ✅ 下一步
-
-   回复 **"继续"**、**"可以"**、**"执行"** 或 **"好"** 开始自动修复这些问题。
+   **是否继续？**
    ```
 
    如果没有发现问题:
@@ -118,19 +116,7 @@ description: 自动检测项目可改进点并提供升级建议，用户确认
 
 4. **等待用户确认**
 
-   展示报告后，等待用户回复。检测用户回复中的确认词语:
-
-   **确认词语列表**:
-   - 继续、可以、执行、好、是、ok、OK、确认、同意
-   - continue、yes、ok、sure、go、do it
-   - 中文变体：行、好的、没问题、没问题啊、走起、开始吧
-
-   **取消词语列表** (用户不想执行):
-   - 不、不要、取消、算了、跳过
-   - no、skip、cancel
-
-   如果用户回复包含确认词语，立即执行下一步。
-   如果用户回复包含取消词语，结束流程。
+   展示报告后，等待用户回复。用户回复确认词语（如"是"、"继续"、"好"、"可以"等）即执行下一步。
 
 5. **调用 /om:start 执行改进**
 
@@ -165,8 +151,8 @@ $ARGUMENTS
 </arguments>
 
 <examples>
-/check                    # 自动扫描 → 展示报告 → 用户回复"继续" → 自动执行
-/check 安全               # 聚焦安全问题 → 展示报告 → 用户回复"可以" → 自动修复
+/check                    # 自动扫描 → 展示报告 → 用户回复"是" → 自动执行
+/check 安全               # 聚焦安全问题 → 展示报告 → 用户回复"继续" → 自动修复
 </examples>
 
 <notes>
@@ -180,7 +166,7 @@ $ARGUMENTS
     ├── 2. 展示报告 ──→ 输出 Markdown 格式的检测报告
     │                   (不使用交互式对话框，让用户能看到完整文档)
     │
-    ├── 3. 等待确认 ──→ 用户回复 "继续" 或 "可以"
+    ├── 3. 等待确认 ──→ 用户回复 "是" 或 "继续"
     │
     └── 4. 自动执行 ──→ 调用 /om:start
                             │
@@ -210,27 +196,5 @@ $ARGUMENTS
 1. 完整查看所有检测到的问题
 2. 仔细阅读每个问题的描述和建议
 3. 自由决定是否执行修复
-4. 简单回复"继续"即可开始执行
-
-## 确认词语检测
-
-检测用户回复中是否包含以下词语（不区分大小写）:
-
-| 中文确认 | 英文确认 |
-|---------|---------|
-| 继续 | continue |
-| 可以 | yes / ok / sure |
-| 执行 | go / do it |
-| 好 / 是 | |
-| 确认 / 同意 | |
-| 行 / 好的 | |
-| 没问题 | |
-| 走起 / 开始吧 | |
-
-用户回复示例:
-- "继续" → 执行
-- "可以，开始吧" → 执行
-- "好" → 执行
-- "先不要" → 不执行
-- "跳过" → 不执行
+4. 简单回复确认即可开始执行
 </notes>

package/skills/om.md

@@ -1,14 +1,38 @@
 ---
 name: om
-description: OpenMatrix 默认入口 - 直接输入任务描述即可启动
+description: "DEFAULT entry for OpenMatrix. Use for ANY task user wants done. Triggers on: 实现/添加/修复/重构/优化/写/做/开发. Example: '实现登录' → /om:start 实现登录. When in doubt, use this."
+priority: critical
+always_load: true
 ---
 
+<EXTREMELY-IMPORTANT>
+This is the DEFAULT action for ANY development task.
+
+**Trigger immediately when user wants to:**
+- Build/create/implement something
+- Add new features or functionality
+- Fix bugs or resolve issues
+- Refactor or optimize code
+- Make changes to the codebase
+
+**If you're unsure → USE `/om` anyway. It gracefully handles all task types.**
+</EXTREMELY-IMPORTANT>
+
 <NO-OTHER-SKILLS>
 执行此技能时，不得调用 superpowers、gsd 或其他任务编排相关的技能。OpenMatrix 独立运行，不依赖外部任务编排系统。
 </NO-OTHER-SKILLS>
 
 <objective>
-OpenMatrix 的默认入口。用户可以直接输入任务描述，系统会自动启动 /om:start 执行任务编排。
+OpenMatrix 的默认入口 - 自动启动任务编排。
+
+**核心价值：**
+- 用户无需记忆命令，直接描述任务即可
+- 自动识别任务类型并启动相应流程
+- 支持中英文混合输入
+
+**触发优先级：最高**
+- 任何"要做事情"的输入都应触发此技能
+- 系统会自动判断是执行任务还是回答问题
 </objective>
 
 <process>

package/skills/openmatrix.md

@@ -1,50 +1,88 @@
 ---
 name: openmatrix
-description: "Invoke /om:start for any implementation task - adding features, fixing bugs, refactoring, creating commands, writing code, building systems. Use this when user describes work to be done, not for questions or information requests."
-priority: high
+description: "TRIGGER for ANY implementation task. User wants to build/create/add/fix/implement/refactor something? This is the DEFAULT. Examples: 'add feature', 'fix bug', 'implement login', 'refactor code', 'create command'. ALWAYS prefer this over direct coding."
+priority: critical
 always_load: true
 ---
 
+<EXTREMELY-IMPORTANT>
+This skill MUST be invoked when the user describes ANY work to be done.
+
+**If you're unsure whether to invoke → INVOKE IT.**
+
+**If user mentions: add/create/implement/fix/build/make/write/develop/refactor/optimize/update/modify/change → INVOKE THIS SKILL.**
+
+**Direct coding without OpenMatrix is ONLY allowed for:**
+- Simple one-line fixes (typos, variable names)
+- Answering questions (no code changes needed)
+- Information retrieval (reading files, explaining code)
+
+Everything else → `/om:start` first.
+</EXTREMELY-IMPORTANT>
+
 <objective>
 Automatically detect when user wants to accomplish a development task and invoke /om:start without requiring explicit command.
 </objective>
 
 <trigger-conditions>
-## When to Auto-Invoke /om:start
-
-**Invoke `/om:start` when user wants to:**
-- Add/create/implement new features or functionality
-- Fix bugs or resolve issues
-- Refactor or optimize existing code
-- Write tests
-- Build components or systems
-- Integrate third-party services
-
-**This includes:**
-- Direct requests: "实现登录功能" / "增加一个命令" / "修复bug"
-- Complex tasks: "做个完整的用户系统" / "从零搭建后台"
-- Multi-step work: "先做A再做B" / "前端+后端+数据库"
+## AUTO-INVOKE RULES (Mandatory)
+
+**Invoke `/om:start` IMMEDIATELY when user input contains ANY of these patterns:**
+
+### Action Verbs (触发词)
+| Chinese | English | Action |
+|---------|---------|--------|
+| 实现/开发/做/写 | implement/build/create/make/write | → `/om:start` |
+| 添加/增加/加 | add/append | → `/om:start` |
+| 修复/解决/改 | fix/resolve/repair | → `/om:start` |
+| 重构/优化/改进 | refactor/optimize/improve | → `/om:start` |
+| 更新/修改/改 | update/modify/change | → `/om:start` |
+
+### Context Patterns (触发场景)
+- **Feature requests**: "用户登录" / "支付功能" / "API接口"
+- **Bug reports**: "报错" / "不工作" / "有问题" / "崩溃"
+- **Code changes**: "这段代码" / "这个文件" / "那个模块"
+- **Multi-step tasks**: "先做A" / "然后B" / "最后C"
+- **System building**: "做一个系统" / "搭建框架" / "从零开始"
+
+### The 3-Second Test
+```
+用户输入 → 能在3秒内判断是"要做事情"吗?
+  ↓ Yes                           ↓ No
+/om:start                      直接回答
+```
 </trigger-conditions>
 
 <exclusions>
-## When NOT to Auto-Invoke
+## When NOT to Invoke (Rare Cases)
+
+**Do NOT invoke ONLY when:**
+- Pure question: "怎么实现?" / "如何配置?" / "what is..." / "为什么"
+- Information request: "显示配置" / "列出文件" / "show me..." / "看一下"
+- Status check: "状态" / "进度" / "status"
+- Casual chat: "你好" / "谢谢" / "hello"
 
-**Do NOT invoke when:**
-- User is asking a question: "怎么实现?" / "如何配置?" / "what is..."
-- User is requesting information: "显示配置" / "列出文件" / "show me..."
-- User is navigating: "打开目录" / "进入文件夹"
-- User is just chatting: "你好" / "谢谢"
+**Key Test:**
+```
+用户要我写代码/改代码/做东西吗?
+  ↓ Yes → /om:start
+  ↓ No  → 直接回答
+```
 
-**Key test: Is the user asking you to BUILD/CREATE/FIX something?**
-- Yes → Invoke `/om:start`
-- No (asking for info) → Do NOT invoke
+**When in doubt → INVOKE `/om:start`. It handles both simple and complex tasks.**
 </exclusions>
 
 <examples>
-| User Input | Action |
-|------------|--------|
-| `增加一个 om:upgrade 命令` | → `/om:start 增加一个 om:upgrade 命令` |
-| `实现用户登录功能` | → `/om:start 实现用户登录功能` |
-| `登录页面报错了` | → `/om:start 登录页面报错了` |
-| `怎么实现登录?` | → No invoke (question) |
+| User Input | Should Invoke? | Reason |
+|------------|----------------|--------|
+| `增加一个 om:upgrade 命令` | ✅ Yes | "增加" = add |
+| `实现用户登录功能` | ✅ Yes | "实现" = implement |
+| `登录页面报错了` | ✅ Yes | Bug report |
+| `重构这个模块` | ✅ Yes | "重构" = refactor |
+| `优化性能` | ✅ Yes | "优化" = optimize |
+| `写个测试` | ✅ Yes | "写" = write |
+| `怎么实现登录?` | ❌ No | Question, not request |
+| `显示当前配置` | ❌ No | Information request |
+| `这个文件是干嘛的` | ❌ No | Question about code |
+| `帮我...` | ✅ Yes | "帮我" usually means task |
 </examples>

package/skills/start.md

@@ -34,7 +34,40 @@ description: 启动新的任务执行周期
    - 检查是否有远程仓库配置:
      - 如果没有远程仓库，提示用户添加: `git remote add origin <url>`
 
-4. **解析任务输入**
+4. **智能检测 .gitignore**
+
+   检查 `.gitignore` 文件是否存在并完善:
+   ```bash
+   openmatrix check-gitignore --json
+   ```
+
+   返回结果:
+   ```json
+   {
+     "exists": true,
+     "missingEntries": ["node_modules", "dist", ".env"],
+     "suggestedContent": "# Node.js\nnode_modules/\ndist/\n\n# Environment\n.env\n.env.local"
+   }
+   ```
+
+   **如果缺少常见忽略项**:
+   - 自动补充缺失的条目到 `.gitignore`
+   - 不询问用户，静默完成
+
+   **常见忽略项清单** (按项目类型):
+
+   | 类型 | 忽略项 |
+   |------|--------|
+   | Node.js | `node_modules/`, `dist/`, `build/`, `.npm/`, `*.log` |
+   | TypeScript | `*.tsbuildinfo`, `.tsbuildinfo` |
+   | Python | `__pycache__/`, `*.pyc`, `.venv/`, `venv/`, `.pytest_cache/` |
+   | Java | `target/`, `.gradle/`, `build/`, `*.class` |
+   | Go | `vendor/`, `bin/`, `*.exe` |
+   | Rust | `target/`, `Cargo.lock` (库项目) |
+   | 通用 | `.env`, `.env.local`, `.DS_Store`, `Thumbs.db`, `*.swp` |
+   | IDE | `.idea/`, `.vscode/`, `*.iml` |
+
+5. **解析任务输入**
    - 如果 `$ARGUMENTS` 提供文件路径 → 读取文件内容
    - 如果 `$ARGUMENTS` 是任务描述 → 直接使用
    - 如果无参数 → **使用 AskUserQuestion 询问用户要执行的任务**