test(targets): add branch coverage for all 6 new P0-TierA targets

Adds 87 new tests covering previously untested code branches:

- aider: lint.ts (hooks/permissions/mcp warnings), linter.ts (scope branches),
  generator edge cases, importer default scope
- amazon-q: linter.ts (scope branches, glob matching)
- augment-code: descriptor.ts (mergeAugmentSettings edge cases,
  emitScopedSettings, buildSettingsContent), lint.ts (hook event validation),
  global layout fall-through, global scope import
- crush: config-format.ts (buildCrushConfigJson, mergeCrushConfigJson),
  lint.ts (lintCommands), global layout fall-through, empty hooks/permissions
- qwen-code: lint.ts, linter.ts (scope branches), generator edge cases
  (empty body, empty allowed-tools), global layout rewriteGeneratedPath
- trae: linter.ts (scope branches), generator edge cases (no root, empty),
  importer global scope, default scope

Author: serhiizhabskiy

tests/unit/targets/aider/generator.test.ts

@@ -110,6 +110,36 @@ describe('generateRules (aider)', () => {
     const results = generateRules(canonical);
     expect(results).toHaveLength(0);
   });
+
+  it('generates CONVENTIONS.md with only non-root rules (no root)', () => {
+    const canonical = makeCanonical({
+      rules: [
+        {
+          source: '/proj/.agentsmesh/rules/typescript.md',
+          root: false,
+          targets: [],
+          description: 'TypeScript standards',
+          globs: ['src/**/*.ts'],
+          body: 'Use strict mode.',
+        },
+        {
+          source: '/proj/.agentsmesh/rules/security.md',
+          root: false,
+          targets: [],
+          description: 'Security',
+          globs: [],
+          body: 'No secrets.',
+        },
+      ],
+    });
+
+    const results = generateRules(canonical);
+
+    expect(results).toHaveLength(1);
+    expect(results[0].path).toBe(AIDER_CONVENTIONS);
+    expect(results[0].content).toContain('Use strict mode.');
+    expect(results[0].content).toContain('No secrets.');
+  });
 });
 
 describe('generateSkills (aider)', () => {

tests/unit/targets/aider/global-layout.test.ts

@@ -35,6 +35,11 @@ describe('aider global layout', () => {
     expect(rewrite(skillPath, '')).toBe(expectedPath);
   });
 
+  it('rewriteGeneratedPath passes through unknown paths unchanged', () => {
+    const rewrite = descriptor.globalSupport!.layout.rewriteGeneratedPath!;
+    expect(rewrite('some/unknown/path.txt', '')).toBe('some/unknown/path.txt');
+  });
+
   it('globalSupport.capabilities matches project capabilities', () => {
     expect(descriptor.globalSupport!.capabilities).toEqual(descriptor.capabilities);
   });

tests/unit/targets/aider/importer.test.ts

@@ -78,4 +78,21 @@ describe('importFromAider', () => {
 
     rmSync(projectRoot, { recursive: true, force: true });
   });
+
+  it('defaults to project scope when no scope option is passed', async () => {
+    projectRoot = setupFixture({
+      'CONVENTIONS.md': '# Project Instructions\n\nUse TDD.',
+    });
+
+    const withoutScope = await importFromAider(projectRoot);
+    const withProjectScope = await importFromAider(projectRoot, { scope: 'project' });
+
+    expect(withoutScope).toHaveLength(withProjectScope.length);
+    for (let i = 0; i < withoutScope.length; i++) {
+      expect(withoutScope[i].toPath).toBe(withProjectScope[i].toPath);
+      expect(withoutScope[i].feature).toBe(withProjectScope[i].feature);
+    }
+
+    rmSync(projectRoot, { recursive: true, force: true });
+  });
 });

tests/unit/targets/aider/lint.test.ts

@@ -0,0 +1,138 @@
+import { describe, it, expect } from 'vitest';
+import type { CanonicalFiles } from '../../../../src/core/types.js';
+import {
+  lintHooks,
+  lintPermissions,
+  lintMcp,
+} from '../../../../src/targets/aider/lint.js';
+
+function makeCanonical(overrides: Partial<CanonicalFiles> = {}): CanonicalFiles {
+  return {
+    rules: [],
+    commands: [],
+    agents: [],
+    skills: [],
+    mcp: null,
+    permissions: null,
+    hooks: null,
+    ignore: [],
+    ...overrides,
+  };
+}
+
+describe('lintHooks (aider)', () => {
+  it('returns empty when hooks is null', () => {
+    const canonical = makeCanonical({ hooks: null });
+    expect(lintHooks(canonical)).toHaveLength(0);
+  });
+
+  it('returns empty when hooks has no entries', () => {
+    const canonical = makeCanonical({
+      hooks: { PreGenerate: [], PostGenerate: [] },
+    });
+    expect(lintHooks(canonical)).toHaveLength(0);
+  });
+
+  it('returns warning when hooks have entries', () => {
+    const canonical = makeCanonical({
+      hooks: {
+        PreGenerate: [{ command: 'echo hello', pattern: '' }],
+      },
+    });
+
+    const result = lintHooks(canonical);
+
+    expect(result).toHaveLength(1);
+    expect(result[0].level).toBe('warning');
+    expect(result[0].target).toBe('aider');
+    expect(result[0].message).toContain('hook');
+  });
+});
+
+describe('lintPermissions (aider)', () => {
+  it('returns empty when permissions is null', () => {
+    const canonical = makeCanonical({ permissions: null });
+    expect(lintPermissions(canonical)).toHaveLength(0);
+  });
+
+  it('returns empty when all permission lists are empty', () => {
+    const canonical = makeCanonical({
+      permissions: { allow: [], deny: [], ask: [] },
+    });
+    expect(lintPermissions(canonical)).toHaveLength(0);
+  });
+
+  it('returns warning when allow list has entries', () => {
+    const canonical = makeCanonical({
+      permissions: { allow: ['Bash'], deny: [], ask: [] },
+    });
+
+    const result = lintPermissions(canonical);
+
+    expect(result).toHaveLength(1);
+    expect(result[0].level).toBe('warning');
+    expect(result[0].target).toBe('aider');
+    expect(result[0].message).toContain('permissions');
+  });
+
+  it('returns warning when deny list has entries', () => {
+    const canonical = makeCanonical({
+      permissions: { allow: [], deny: ['WebSearch'], ask: [] },
+    });
+
+    const result = lintPermissions(canonical);
+
+    expect(result).toHaveLength(1);
+    expect(result[0].level).toBe('warning');
+  });
+
+  it('returns warning when ask list has entries', () => {
+    const canonical = makeCanonical({
+      permissions: { allow: [], deny: [], ask: ['Bash'] },
+    });
+
+    const result = lintPermissions(canonical);
+
+    expect(result).toHaveLength(1);
+    expect(result[0].level).toBe('warning');
+  });
+
+  it('returns empty when permissions has no ask property', () => {
+    const canonical = makeCanonical({
+      permissions: { allow: [], deny: [] },
+    });
+    expect(lintPermissions(canonical)).toHaveLength(0);
+  });
+});
+
+describe('lintMcp (aider)', () => {
+  it('returns empty when mcp is null', () => {
+    const canonical = makeCanonical({ mcp: null });
+    expect(lintMcp(canonical)).toHaveLength(0);
+  });
+
+  it('returns empty when mcpServers is empty', () => {
+    const canonical = makeCanonical({ mcp: { mcpServers: {} } });
+    expect(lintMcp(canonical)).toHaveLength(0);
+  });
+
+  it('returns warning when mcp has servers', () => {
+    const canonical = makeCanonical({
+      mcp: {
+        mcpServers: {
+          context7: {
+            command: 'npx',
+            args: ['-y', '@upstash/context7-mcp'],
+          },
+        },
+      },
+    });
+
+    const result = lintMcp(canonical);
+
+    expect(result).toHaveLength(1);
+    expect(result[0].level).toBe('warning');
+    expect(result[0].target).toBe('aider');
+    expect(result[0].message).toContain('MCP');
+  });
+});

tests/unit/targets/aider/linter.test.ts

@@ -0,0 +1,99 @@
+import { describe, it, expect } from 'vitest';
+import type { CanonicalFiles } from '../../../../src/core/types.js';
+import { lintRules } from '../../../../src/targets/aider/linter.js';
+
+function makeCanonical(overrides: Partial<CanonicalFiles> = {}): CanonicalFiles {
+  return {
+    rules: [],
+    commands: [],
+    agents: [],
+    skills: [],
+    mcp: null,
+    permissions: null,
+    hooks: null,
+    ignore: [],
+    ...overrides,
+  };
+}
+
+describe('lintRules (aider)', () => {
+  it('returns empty diagnostics for empty rules', () => {
+    const result = lintRules(makeCanonical(), '/proj', []);
+    expect(result).toHaveLength(0);
+  });
+
+  it('sets target to aider on all diagnostics', () => {
+    const canonical = makeCanonical({
+      rules: [
+        {
+          source: '/proj/.agentsmesh/rules/typescript.md',
+          root: false,
+          targets: [],
+          description: '',
+          globs: ['src/**/*.ts'],
+          body: 'body',
+        },
+      ],
+    });
+
+    const result = lintRules(canonical, '/proj', []);
+    for (const d of result) {
+      expect(d.target).toBe('aider');
+    }
+  });
+
+  it('skips glob matching in global scope', () => {
+    const canonical = makeCanonical({
+      rules: [
+        {
+          source: '/proj/.agentsmesh/rules/_root.md',
+          root: true,
+          targets: [],
+          description: '',
+          globs: [],
+          body: '# Root',
+        },
+        {
+          source: '/proj/.agentsmesh/rules/unmatched.md',
+          root: false,
+          targets: [],
+          description: '',
+          globs: ['nonexistent/**/*.xyz'],
+          body: 'body',
+        },
+      ],
+    });
+
+    const globalResult = lintRules(canonical, '/proj', [], { scope: 'global' });
+    expect(globalResult).toHaveLength(0);
+  });
+
+  it('checks glob matches in project scope', () => {
+    const canonical = makeCanonical({
+      rules: [
+        {
+          source: '/proj/.agentsmesh/rules/_root.md',
+          root: true,
+          targets: [],
+          description: '',
+          globs: [],
+          body: '# Root',
+        },
+        {
+          source: '/proj/.agentsmesh/rules/unmatched.md',
+          root: false,
+          targets: [],
+          description: '',
+          globs: ['nonexistent/**/*.xyz'],
+          body: 'body',
+        },
+      ],
+    });
+
+    const projectResult = lintRules(canonical, '/proj', ['src/index.ts'], {
+      scope: 'project',
+    });
+    expect(projectResult.length).toBeGreaterThan(0);
+    expect(projectResult.some((d) => d.level === 'warning')).toBe(true);
+  });
+});