@geminilight/mindos 0.6.74 → 0.6.75

package/_standalone/__tests__/core/search-index.test.ts

@@ -0,0 +1,239 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkTempMindRoot, cleanupMindRoot, seedFile } from './helpers';
+import { SearchIndex } from '@/lib/core/search-index';
+
+describe('SearchIndex', () => {
+  let mindRoot: string;
+  let index: SearchIndex;
+
+  beforeEach(() => {
+    mindRoot = mkTempMindRoot();
+    seedFile(mindRoot, 'Profile/Identity.md', '# My Identity\n\nI am a developer working on MindOS.');
+    seedFile(mindRoot, 'Projects/TODO.md', '# TODO\n\n- Fix the bug\n- Add search feature');
+    seedFile(mindRoot, 'Resources/data.csv', 'name,value\nfoo,bar\nbaz,qux');
+    seedFile(mindRoot, 'Archive/old.md', 'This is archived content about search.');
+    index = new SearchIndex();
+  });
+
+  afterEach(() => {
+    cleanupMindRoot(mindRoot);
+  });
+
+  describe('rebuild', () => {
+    it('builds an index from files in mindRoot', () => {
+      index.rebuild(mindRoot);
+      expect(index.isBuilt()).toBe(true);
+    });
+
+    it('indexes all files', () => {
+      index.rebuild(mindRoot);
+      expect(index.getFileCount()).toBe(4);
+    });
+  });
+
+  describe('getCandidates', () => {
+    it('returns file paths containing the query token', () => {
+      index.rebuild(mindRoot);
+      const candidates = index.getCandidates('search');
+      expect(candidates).toContain('Projects/TODO.md');
+      expect(candidates).toContain('Archive/old.md');
+    });
+
+    it('returns empty set for non-existent token', () => {
+      index.rebuild(mindRoot);
+      const candidates = index.getCandidates('xyznonexistent123');
+      expect(candidates).toHaveLength(0);
+    });
+
+    it('is case-insensitive', () => {
+      index.rebuild(mindRoot);
+      const candidates = index.getCandidates('DEVELOPER');
+      expect(candidates).toContain('Profile/Identity.md');
+    });
+
+    it('intersects candidates for multi-word queries', () => {
+      index.rebuild(mindRoot);
+      // "search feature" should narrow to Projects/TODO.md (has both words)
+      const candidates = index.getCandidates('search feature');
+      expect(candidates).toContain('Projects/TODO.md');
+      // Archive/old.md has "search" but NOT "feature" — must be excluded by intersection
+      expect(candidates).not.toContain('Archive/old.md');
+    });
+  });
+
+  describe('CJK support', () => {
+    it('indexes CJK characters as bigrams', () => {
+      seedFile(mindRoot, 'Notes/chinese.md', '知识库是一个管理工具');
+      index.rebuild(mindRoot);
+      const candidates = index.getCandidates('知识');
+      expect(candidates).toContain('Notes/chinese.md');
+    });
+
+    it('getCandidatesUnion prunes low-overlap CJK files', () => {
+      // "知识管理系统" produces many bigrams: 知识, 识管, 管理, 理系, 系统
+      // File A has "知识管理系统" (all bigrams match)
+      // File B has only "知识" (1 bigram matches)
+      // File C has "管理" (1 bigram matches)
+      seedFile(mindRoot, 'Notes/full-match.md', '知识管理系统是核心');
+      seedFile(mindRoot, 'Notes/partial-a.md', '这是知识的来源');
+      seedFile(mindRoot, 'Notes/partial-b.md', '我们要管理好时间');
+      index.rebuild(mindRoot);
+
+      const candidates = index.getCandidatesUnion('知识管理系统');
+      expect(candidates).not.toBeNull();
+      // Full match file should always be included
+      expect(candidates).toContain('Notes/full-match.md');
+      // Partial matches (only 1 bigram) should be pruned when threshold >= 2
+      expect(candidates).not.toContain('Notes/partial-a.md');
+      expect(candidates).not.toContain('Notes/partial-b.md');
+    });
+
+    it('handles mixed CJK and Latin query', () => {
+      seedFile(mindRoot, 'Notes/mixed.md', '这是一个MindOS知识库文件');
+      index.rebuild(mindRoot);
+      const candidates = index.getCandidates('mindos');
+      expect(candidates).toContain('Notes/mixed.md');
+    });
+  });
+
+  describe('invalidate', () => {
+    it('clears the index', () => {
+      index.rebuild(mindRoot);
+      expect(index.isBuilt()).toBe(true);
+      index.invalidate();
+      expect(index.isBuilt()).toBe(false);
+    });
+
+    it('returns null candidates after invalidation (triggers full scan fallback)', () => {
+      index.rebuild(mindRoot);
+      index.invalidate();
+      expect(index.getCandidates('search')).toBeNull();
+    });
+  });
+
+  describe('isBuiltFor', () => {
+    it('returns true for the root it was built with', () => {
+      index.rebuild(mindRoot);
+      expect(index.isBuiltFor(mindRoot)).toBe(true);
+    });
+
+    it('returns false for a different root', () => {
+      index.rebuild(mindRoot);
+      expect(index.isBuiltFor('/some/other/root')).toBe(false);
+    });
+
+    it('returns false after invalidation', () => {
+      index.rebuild(mindRoot);
+      index.invalidate();
+      expect(index.isBuiltFor(mindRoot)).toBe(false);
+    });
+  });
+
+  describe('substring queries (no tokens produced)', () => {
+    it('returns null for single-char Latin query (falls back to full scan)', () => {
+      index.rebuild(mindRoot);
+      // "a" is too short to produce tokens → null → caller does full scan
+      expect(index.getCandidates('a')).toBeNull();
+    });
+
+    it('returns null for partial-word queries that produce no tokens', () => {
+      index.rebuild(mindRoot);
+      // "x" produces no token → null → preserves indexOf substring matching
+      expect(index.getCandidates('x')).toBeNull();
+    });
+  });
+
+  describe('special characters', () => {
+    it('handles query with regex special chars', () => {
+      seedFile(mindRoot, 'Notes/special.md', 'price is $100.00 (USD)');
+      index.rebuild(mindRoot);
+      const candidates = index.getCandidates('$100');
+      expect(candidates).toContain('Notes/special.md');
+    });
+
+    it('handles empty query', () => {
+      index.rebuild(mindRoot);
+      expect(index.getCandidates('')).toBeNull();
+    });
+  });
+
+  describe('large content truncation', () => {
+    it('truncates files larger than 50KB for indexing', () => {
+      const largeContent = 'uniquetoken '.repeat(10_000); // ~120KB
+      seedFile(mindRoot, 'Notes/large.md', largeContent);
+      index.rebuild(mindRoot);
+      const candidates = index.getCandidates('uniquetoken');
+      expect(candidates).toContain('Notes/large.md');
+    });
+  });
+
+  describe('incremental updates', () => {
+    it('updateFile re-indexes a modified file without full rebuild', () => {
+      index.rebuild(mindRoot);
+      expect(index.getCandidates('quantum')).toHaveLength(0);
+
+      // Modify file to contain new term
+      seedFile(mindRoot, 'Profile/Identity.md', '# My Identity\n\nI study quantum computing.');
+      index.updateFile(mindRoot, 'Profile/Identity.md');
+
+      const candidates = index.getCandidates('quantum');
+      expect(candidates).toContain('Profile/Identity.md');
+      // Old term should still be findable in other files
+      expect(index.getCandidates('search')).toContain('Projects/TODO.md');
+    });
+
+    it('updateFile removes old tokens that no longer exist in file', () => {
+      index.rebuild(mindRoot);
+      expect(index.getCandidates('developer')).toContain('Profile/Identity.md');
+
+      // Rewrite file without "developer"
+      seedFile(mindRoot, 'Profile/Identity.md', '# My Identity\n\nI am a designer.');
+      index.updateFile(mindRoot, 'Profile/Identity.md');
+
+      expect(index.getCandidates('developer')).toHaveLength(0);
+      expect(index.getCandidates('designer')).toContain('Profile/Identity.md');
+    });
+
+    it('updateFile maintains correct fileCount', () => {
+      index.rebuild(mindRoot);
+      expect(index.getFileCount()).toBe(4);
+
+      seedFile(mindRoot, 'Profile/Identity.md', 'updated content');
+      index.updateFile(mindRoot, 'Profile/Identity.md');
+
+      expect(index.getFileCount()).toBe(4); // same file, count unchanged
+    });
+
+    it('removeFile removes a file from the index', () => {
+      index.rebuild(mindRoot);
+      expect(index.getCandidates('archived')).toContain('Archive/old.md');
+
+      index.removeFile('Archive/old.md');
+
+      expect(index.getCandidates('archived')).toHaveLength(0);
+      expect(index.getFileCount()).toBe(3);
+    });
+
+    it('addFile indexes a new file without full rebuild', () => {
+      index.rebuild(mindRoot);
+      expect(index.getFileCount()).toBe(4);
+
+      seedFile(mindRoot, 'Notes/fresh.md', 'brand new blockchain content');
+      index.addFile(mindRoot, 'Notes/fresh.md');
+
+      expect(index.getFileCount()).toBe(5);
+      expect(index.getCandidates('blockchain')).toContain('Notes/fresh.md');
+    });
+
+    it('updateFile updates BM25 docLength stats', () => {
+      index.rebuild(mindRoot);
+      const oldLen = index.getDocLength('Profile/Identity.md');
+
+      seedFile(mindRoot, 'Profile/Identity.md', 'short');
+      index.updateFile(mindRoot, 'Profile/Identity.md');
+
+      expect(index.getDocLength('Profile/Identity.md')).toBe(5);
+      expect(index.getDocLength('Profile/Identity.md')).not.toBe(oldLen);
+    });
+  });
+});

package/_standalone/__tests__/core/search.test.ts

@@ -0,0 +1,68 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkTempMindRoot, cleanupMindRoot, seedFile } from './helpers';
+import { searchFiles } from '@/lib/core/search';
+
+describe('search', () => {
+  let mindRoot: string;
+
+  beforeEach(() => {
+    mindRoot = mkTempMindRoot();
+    seedFile(mindRoot, 'Profile/Identity.md', '# My Identity\n\nI am a developer working on MindOS.');
+    seedFile(mindRoot, 'Projects/TODO.md', '# TODO\n\n- Fix the bug\n- Add search feature');
+    seedFile(mindRoot, 'Resources/data.csv', 'name,value\nfoo,bar\nbaz,qux');
+    seedFile(mindRoot, 'Archive/old.md', 'This is archived content about search.');
+  });
+  afterEach(() => { cleanupMindRoot(mindRoot); });
+
+  it('finds files containing the query (case-insensitive)', () => {
+    const results = searchFiles(mindRoot, 'search');
+    expect(results.length).toBeGreaterThanOrEqual(2);
+    const paths = results.map(r => r.path);
+    expect(paths).toContain('Projects/TODO.md');
+    expect(paths).toContain('Archive/old.md');
+  });
+
+  it('returns empty for empty query', () => {
+    expect(searchFiles(mindRoot, '')).toEqual([]);
+    expect(searchFiles(mindRoot, '   ')).toEqual([]);
+  });
+
+  it('returns empty when no match', () => {
+    expect(searchFiles(mindRoot, 'xyznonexistent123')).toEqual([]);
+  });
+
+  it('respects scope filter', () => {
+    const results = searchFiles(mindRoot, 'search', { scope: 'Projects/' });
+    expect(results.every(r => r.path.startsWith('Projects/'))).toBe(true);
+  });
+
+  it('respects file_type filter', () => {
+    const results = searchFiles(mindRoot, 'foo', { file_type: 'csv' });
+    expect(results).toHaveLength(1);
+    expect(results[0].path).toBe('Resources/data.csv');
+  });
+
+  it('respects limit', () => {
+    const results = searchFiles(mindRoot, 'the', { limit: 1 });
+    expect(results.length).toBeLessThanOrEqual(1);
+  });
+
+  it('includes snippet and score', () => {
+    const results = searchFiles(mindRoot, 'developer');
+    expect(results.length).toBeGreaterThan(0);
+    expect(results[0].snippet).toContain('developer');
+    expect(results[0].score).toBeGreaterThan(0);
+    expect(results[0].occurrences).toBeGreaterThan(0);
+  });
+
+  it('sorts by score (occurrence density) descending', () => {
+    seedFile(mindRoot, 'many.md', 'test test test test test');
+    seedFile(mindRoot, 'few.md', 'test and lots of other words that dilute the density of matches significantly');
+    const results = searchFiles(mindRoot, 'test');
+    const manyIdx = results.findIndex(r => r.path === 'many.md');
+    const fewIdx = results.findIndex(r => r.path === 'few.md');
+    if (manyIdx !== -1 && fewIdx !== -1) {
+      expect(manyIdx).toBeLessThan(fewIdx);
+    }
+  });
+});

package/_standalone/__tests__/core/security.test.ts

@@ -0,0 +1,85 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkTempMindRoot, cleanupMindRoot } from './helpers';
+import {
+  resolveSafe,
+  assertNotProtected,
+  isRootProtected,
+  assertWithinRoot,
+} from '@/lib/core/security';
+import { MindOSError, ErrorCodes } from '@/lib/errors';
+import path from 'path';
+
+describe('security', () => {
+  let mindRoot: string;
+
+  beforeEach(() => { mindRoot = mkTempMindRoot(); });
+  afterEach(() => { cleanupMindRoot(mindRoot); });
+
+  describe('resolveSafe', () => {
+    it('resolves a valid relative path', () => {
+      const resolved = resolveSafe(mindRoot, 'foo/bar.md');
+      expect(resolved).toBe(path.resolve(mindRoot, 'foo/bar.md'));
+    });
+
+    it('throws MindOSError with PATH_OUTSIDE_ROOT on path traversal', () => {
+      try {
+        resolveSafe(mindRoot, '../../../etc/passwd');
+        expect.fail('should have thrown');
+      } catch (err) {
+        expect(err).toBeInstanceOf(MindOSError);
+        expect((err as MindOSError).code).toBe(ErrorCodes.PATH_OUTSIDE_ROOT);
+      }
+    });
+
+    it('throws on path that escapes via symlink-like traversal', () => {
+      // path.join normalizes away leading /, so we use .. to escape
+      expect(() => resolveSafe(mindRoot, '../../../../../../etc/passwd')).toThrow('Access denied');
+    });
+
+    it('allows paths that resolve to root itself', () => {
+      const resolved = resolveSafe(mindRoot, '.');
+      expect(resolved).toBe(path.resolve(mindRoot));
+    });
+
+    it('prevents double-encoded path traversal', () => {
+      expect(() => resolveSafe(mindRoot, 'foo/../../..')).toThrow('Access denied');
+    });
+  });
+
+  describe('assertWithinRoot', () => {
+    it('does not throw for paths within root', () => {
+      const root = path.resolve(mindRoot);
+      expect(() => assertWithinRoot(path.join(root, 'file.md'), root)).not.toThrow();
+    });
+
+    it('throws for paths outside root', () => {
+      const root = path.resolve(mindRoot);
+      expect(() => assertWithinRoot('/tmp/other', root)).toThrow('Access denied');
+    });
+  });
+
+  describe('isRootProtected / assertNotProtected', () => {
+    it('marks INSTRUCTION.md as protected', () => {
+      expect(isRootProtected('INSTRUCTION.md')).toBe(true);
+    });
+
+    it('does not mark other files as protected', () => {
+      expect(isRootProtected('README.md')).toBe(false);
+      expect(isRootProtected('nested/INSTRUCTION.md')).toBe(false);
+    });
+
+    it('assertNotProtected throws MindOSError with PROTECTED_FILE for INSTRUCTION.md', () => {
+      try {
+        assertNotProtected('INSTRUCTION.md', 'modified');
+        expect.fail('should have thrown');
+      } catch (err) {
+        expect(err).toBeInstanceOf(MindOSError);
+        expect((err as MindOSError).code).toBe(ErrorCodes.PROTECTED_FILE);
+      }
+    });
+
+    it('assertNotProtected passes for normal files', () => {
+      expect(() => assertNotProtected('README.md', 'modified')).not.toThrow();
+    });
+  });
+});

package/_standalone/__tests__/core/skill-install-logic.test.ts

@@ -0,0 +1,230 @@
+import { describe, it, expect } from 'vitest';
+
+/**
+ * Tests the CLI skill install logic (scripts/setup.js) by replicating the
+ * pure functions. This validates agent filtering, command building, and
+ * source selection without actually spawning npx.
+ */
+
+/* ── Replicated constants from scripts/setup.js ──────────────────── */
+
+const UNIVERSAL_AGENTS = new Set([
+  'amp', 'cline', 'codex', 'cursor', 'gemini-cli',
+  'github-copilot', 'kimi-cli', 'opencode', 'warp',
+]);
+
+const SKILL_UNSUPPORTED = new Set<string>([]);
+
+const SKILL_AGENT_REGISTRY: Record<string, { mode: 'universal' | 'additional' | 'unsupported'; skillAgentName?: string }> = {
+  'claude-code': { mode: 'additional', skillAgentName: 'claude-code' },
+  'cursor': { mode: 'universal' },
+  'windsurf': { mode: 'additional', skillAgentName: 'windsurf' },
+  'cline': { mode: 'universal' },
+  'trae': { mode: 'additional', skillAgentName: 'trae' },
+  'gemini-cli': { mode: 'universal' },
+  'openclaw': { mode: 'additional', skillAgentName: 'openclaw' },
+  'codebuddy': { mode: 'additional', skillAgentName: 'codebuddy' },
+  'iflow-cli': { mode: 'additional', skillAgentName: 'iflow-cli' },
+  'kimi-cli': { mode: 'universal' },
+  'opencode': { mode: 'universal' },
+  'pi': { mode: 'additional', skillAgentName: 'pi' },
+  'augment': { mode: 'additional', skillAgentName: 'augment' },
+  'qwen-code': { mode: 'additional', skillAgentName: 'qwen-code' },
+  'qoder': { mode: 'additional', skillAgentName: 'qoder' },
+  'trae-cn': { mode: 'additional', skillAgentName: 'trae-cn' },
+  'roo': { mode: 'additional', skillAgentName: 'roo' },
+  'github-copilot': { mode: 'universal' },
+  'codex': { mode: 'universal' },
+  'antigravity': { mode: 'additional', skillAgentName: 'antigravity' },
+};
+
+/* ── Replicated logic from scripts/setup.js ──────────────────────── */
+
+function filterAgents(selectedAgents: string[]): string[] {
+  return selectedAgents.flatMap((key) => {
+    if (SKILL_UNSUPPORTED.has(key)) return [];
+    if (UNIVERSAL_AGENTS.has(key)) return [];
+    const reg = SKILL_AGENT_REGISTRY[key];
+    if (!reg) return [key];
+    if (reg.mode === 'unsupported' || reg.mode === 'universal') return [];
+    return [reg.skillAgentName || key];
+  });
+}
+
+function buildAgentFlags(additionalAgents: string[]): string {
+  return additionalAgents.length > 0
+    ? additionalAgents.map(a => `-a ${a}`).join(' ')
+    : '-a universal';
+}
+
+function buildCommand(source: string, skillName: string, agentFlags: string): string {
+  const quotedSource = /[/\\]/.test(source) ? `"${source}"` : source;
+  return `npx skills add ${quotedSource} --skill ${skillName} ${agentFlags} -g -y`;
+}
+
+function resolveSkillName(template: string): string {
+  return template === 'zh' ? 'mindos-zh' : 'mindos';
+}
+
+/* ── Tests ────────────────────────────────────────────────────────── */
+
+describe('CLI skill install — skill name resolution', () => {
+  it('zh template → mindos-zh', () => {
+    expect(resolveSkillName('zh')).toBe('mindos-zh');
+  });
+
+  it('en template → mindos', () => {
+    expect(resolveSkillName('en')).toBe('mindos');
+  });
+
+  it('empty template → mindos', () => {
+    expect(resolveSkillName('empty')).toBe('mindos');
+  });
+
+  it('custom template → mindos', () => {
+    expect(resolveSkillName('custom')).toBe('mindos');
+  });
+});
+
+describe('CLI skill install — agent filtering', () => {
+  it('filters out all universal agents', () => {
+    const agents = ['amp', 'cline', 'codex', 'cursor', 'gemini-cli', 'github-copilot', 'kimi-cli', 'opencode', 'warp'];
+    expect(filterAgents(agents)).toEqual([]);
+  });
+
+  it('keeps non-universal agents', () => {
+    expect(filterAgents(['claude-code', 'windsurf', 'trae'])).toEqual(['claude-code', 'windsurf', 'trae']);
+  });
+
+  it('handles mixed universal + non-universal', () => {
+    const result = filterAgents(['cursor', 'claude-code', 'cline', 'windsurf', 'trae']);
+    expect(result).toEqual(['claude-code', 'windsurf', 'trae']);
+  });
+
+  it('maps agent names via AGENT_NAME_MAP', () => {
+    const result = filterAgents(['openclaw', 'codebuddy']);
+    expect(result).toEqual(['openclaw', 'codebuddy']);
+  });
+
+  it('passes through unknown non-universal agents as-is', () => {
+    const result = filterAgents(['some-new-agent']);
+    expect(result).toEqual(['some-new-agent']);
+  });
+
+  it('handles empty input', () => {
+    expect(filterAgents([])).toEqual([]);
+  });
+});
+
+describe('CLI skill install — agent flag building', () => {
+  it('builds separate -a flags for multiple agents', () => {
+    const flags = buildAgentFlags(['claude-code', 'windsurf', 'trae']);
+    expect(flags).toBe('-a claude-code -a windsurf -a trae');
+  });
+
+  it('builds single -a flag for one agent', () => {
+    expect(buildAgentFlags(['claude-code'])).toBe('-a claude-code');
+  });
+
+  it('falls back to -a universal for empty array', () => {
+    expect(buildAgentFlags([])).toBe('-a universal');
+  });
+
+  it('never produces comma-separated agents', () => {
+    const flags = buildAgentFlags(['claude-code', 'windsurf']);
+    expect(flags).not.toContain(',');
+  });
+});
+
+describe('CLI skill install — command building', () => {
+  it('builds correct GitHub source command (quoted due to /)', () => {
+    const cmd = buildCommand('GeminiLight/MindOS', 'mindos', '-a universal');
+    // GitHub source contains / which triggers quoting — harmless, shell handles it fine
+    expect(cmd).toBe('npx skills add "GeminiLight/MindOS" --skill mindos -a universal -g -y');
+  });
+
+  it('quotes local paths', () => {
+    const cmd = buildCommand('/home/user/project/skills', 'mindos-zh', '-a claude-code');
+    expect(cmd).toBe('npx skills add "/home/user/project/skills" --skill mindos-zh -a claude-code -g -y');
+  });
+
+  it('does not quote simple names without / or \\', () => {
+    const cmd = buildCommand('some-npm-package', 'mindos', '-a universal');
+    expect(cmd).not.toContain('"some-npm-package"');
+    expect(cmd).toContain('some-npm-package');
+  });
+
+  it('quotes Windows-style local paths', () => {
+    const cmd = buildCommand('C:\\Users\\me\\skills', 'mindos', '-a universal');
+    expect(cmd).toContain('"C:\\Users\\me\\skills"');
+  });
+});
+
+describe('CLI skill install — end-to-end scenarios', () => {
+  function simulate(template: string, selectedAgents: string[]) {
+    const skillName = resolveSkillName(template);
+    const filtered = filterAgents(selectedAgents);
+    const agentFlags = buildAgentFlags(filtered);
+    return buildCommand('GeminiLight/MindOS', skillName, agentFlags);
+  }
+
+  it('S1: cursor + claude-code, zh', () => {
+    const cmd = simulate('zh', ['cursor', 'claude-code']);
+    expect(cmd).toBe('npx skills add "GeminiLight/MindOS" --skill mindos-zh -a claude-code -g -y');
+  });
+
+  it('S2: cursor + cline + gemini-cli, en', () => {
+    const cmd = simulate('en', ['cursor', 'cline', 'gemini-cli']);
+    expect(cmd).toBe('npx skills add "GeminiLight/MindOS" --skill mindos -a universal -g -y');
+  });
+
+  it('S3: claude-code + windsurf + trae, zh', () => {
+    const cmd = simulate('zh', ['claude-code', 'windsurf', 'trae']);
+    expect(cmd).toBe('npx skills add "GeminiLight/MindOS" --skill mindos-zh -a claude-code -a windsurf -a trae -g -y');
+  });
+
+  it('S4: only universal agents, en', () => {
+    const cmd = simulate('en', ['cursor', 'cline']);
+    expect(cmd).toBe('npx skills add "GeminiLight/MindOS" --skill mindos -a universal -g -y');
+  });
+
+  it('S5: all universal agents, zh', () => {
+    const cmd = simulate('zh', ['amp', 'cline', 'codex', 'cursor']);
+    expect(cmd).toBe('npx skills add "GeminiLight/MindOS" --skill mindos-zh -a universal -g -y');
+  });
+
+  it('S6: single non-universal (windsurf), en', () => {
+    const cmd = simulate('en', ['windsurf']);
+    expect(cmd).toBe('npx skills add "GeminiLight/MindOS" --skill mindos -a windsurf -g -y');
+  });
+
+  it('S7: all supported non-universal agents, zh', () => {
+    const cmd = simulate('zh', ['claude-code', 'windsurf', 'trae', 'openclaw', 'codebuddy']);
+    expect(cmd).toBe('npx skills add "GeminiLight/MindOS" --skill mindos-zh -a claude-code -a windsurf -a trae -a openclaw -a codebuddy -g -y');
+  });
+
+  it('S8: new agents (augment + roo + pi), en', () => {
+    const cmd = simulate('en', ['augment', 'roo', 'pi']);
+    expect(cmd).toBe('npx skills add "GeminiLight/MindOS" --skill mindos -a augment -a roo -a pi -g -y');
+  });
+
+  it('S9: mix of old + new non-universal agents, zh', () => {
+    const cmd = simulate('zh', ['claude-code', 'augment', 'trae-cn', 'qwen-code']);
+    expect(cmd).toBe('npx skills add "GeminiLight/MindOS" --skill mindos-zh -a claude-code -a augment -a trae-cn -a qwen-code -g -y');
+  });
+
+  it('S9b: includes qoder in additional-agent flags', () => {
+    const cmd = simulate('en', ['qoder', 'cursor']);
+    expect(cmd).toBe('npx skills add "GeminiLight/MindOS" --skill mindos -a qoder -g -y');
+  });
+
+  it('S9c: github-copilot should use universal fallback (no explicit -a)', () => {
+    const cmd = simulate('en', ['github-copilot']);
+    expect(cmd).toBe('npx skills add "GeminiLight/MindOS" --skill mindos -a universal -g -y');
+  });
+
+  it('S10: kimi-cli + opencode are universal, should be filtered', () => {
+    const cmd = simulate('en', ['kimi-cli', 'opencode', 'iflow-cli']);
+    expect(cmd).toBe('npx skills add "GeminiLight/MindOS" --skill mindos -a iflow-cli -g -y');
+  });
+});