spidersan 0.5.0 → 0.9.0

package/dist/commands/conflicts.js

@@ -8,201 +8,39 @@
  *   TIER 3: Block (exit with error, prevent merge)
  */
 import { Command } from 'commander';
-import { execFileSync, spawnSync } from 'child_process';
+import { compilePatterns } from '../lib/regex-utils.js';
+import { spawnSync } from 'child_process';
 import { basename } from 'path';
 import { homedir } from 'os';
 import { getStorage } from '../storage/index.js';
 import { ASTParser } from '../lib/ast.js';
-import { validateAgentId, validateBranchName } from '../lib/security.js';
+import { analyzeConflicts } from '../lib/conflict-analyzer.js';
+import { renderConflictReport } from '../lib/conflict-renderer.js';
+import { getCurrentBranch, getFileAtRef } from '../lib/git.js';
+import { validateBranchName } from '../lib/security.js';
 import { isExcludedPath } from './register.js';
 import { loadConfig } from '../lib/config.js';
 import { logActivity } from '../lib/activity.js';
 import { isGhAvailable, getPRDetails } from '../lib/github.js';
-// Config
-const HUB_URL = process.env.HUB_URL || 'https://hub.treebird.uk';
-// Critical files that trigger TIER 3 blocking
-const TIER_3_PATTERNS = [
-    /\.env$/,
-    /secrets?\./i,
-    /credentials/i,
-    /password/i,
-    /api[_-]?key/i,
-    /private[_-]?key/i,
-    /\.pem$/,
-    /auth\.(ts|js)$/,
-    /security\.(ts|js)$/,
-];
-// Important files that trigger TIER 2 pause
-const TIER_2_PATTERNS = [
-    /package\.json$/,
-    /package-lock\.json$/,
-    /tsconfig\.json$/,
-    /CLAUDE\.md$/,
-    /\.gitignore$/,
-    /server\.(ts|js)$/,
-    /index\.(ts|js)$/,
-    /config\.(ts|js)$/,
-];
-function getConflictTier(file, highSeverityPatterns = [], mediumSeverityPatterns = []) {
-    // Check TIER 3 first (most critical)
-    const tier3 = [...TIER_3_PATTERNS, ...highSeverityPatterns];
-    for (const pattern of tier3) {
-        if (pattern.test(file)) {
-            return {
-                tier: 3,
-                label: 'BLOCK',
-                icon: '🔴',
-                action: 'Merge blocked. Resolve conflict first.'
-            };
-        }
-    }
-    // Check TIER 2 
-    const tier2 = [...TIER_2_PATTERNS, ...mediumSeverityPatterns];
-    for (const pattern of tier2) {
-        if (pattern.test(file)) {
-            return {
-                tier: 2,
-                label: 'PAUSE',
-                icon: '🟠',
-                action: 'Coordinate with other agent before proceeding.'
-            };
-        }
-    }
-    // Default: TIER 1
-    return {
-        tier: 1,
-        label: 'WARN',
-        icon: '🟡',
-        action: 'Consider coordinating, but safe to proceed.'
-    };
-}
-function getCurrentBranch() {
-    try {
-        return execFileSync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], { encoding: 'utf-8' }).trim();
-    }
-    catch {
-        throw new Error('Not in a git repository');
-    }
-}
-async function notifyHub(branch, conflicts) {
-    const tier3 = conflicts.filter(c => c.tier === 3);
-    const tier2 = conflicts.filter(c => c.tier === 2);
-    if (tier3.length === 0 && tier2.length === 0)
-        return;
-    const severity = tier3.length > 0 ? '🔴 TIER 3 BLOCK' : '🟠 TIER 2 PAUSE';
-    const message = `🕷️⚠️ **Conflict Alert** on \`${branch}\`\n\n${severity}\n\nConflicting files require coordination.`;
-    try {
-        await fetch(`${HUB_URL}/api/chat`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({
-                agent: 'spidersan',
-                name: 'Spidersan',
-                message,
-                glyph: '🕷️'
-            })
-        });
-    }
-    catch {
-        // Hub offline - silent fail
-    }
-}
-/**
- * Wake a conflicting agent and send them a message about what to fix
- */
-async function wakeConflictingAgent(agentId, myBranch, theirBranch, conflictingFiles) {
-    const fileList = conflictingFiles.slice(0, 5).join(', ');
-    const more = conflictingFiles.length > 5 ? ` (+${conflictingFiles.length - 5} more)` : '';
-    // 1. Wake the agent via Hub
-    try {
-        const wakeResponse = await fetch(`${HUB_URL}/api/wake/${agentId}`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({
-                sender: 'spidersan',
-                reason: `Conflict on ${theirBranch} - need resolution`
-            })
-        });
-        if (wakeResponse.ok) {
-            console.log(`  🔔 Wake signal sent to ${agentId}`);
-        }
-    }
-    catch {
-        console.log(`  ⚠️ Could not wake ${agentId} via Hub`);
-    }
-    // 2. Send a detailed mycmail message
-    try {
-        const { execFileSync } = await import('child_process');
-        // Security: Validate inputs before shell execution
-        const safeAgentId = validateAgentId(agentId);
-        const safeBranch = validateBranchName(theirBranch);
-        const safeMyBranch = validateBranchName(myBranch);
-        const subject = `🕷️ Conflict Alert: ${safeBranch}`;
-        const body = [
-            `Hey ${safeAgentId}!`,
-            ``,
-            `Spidersan detected a conflict between our branches:`,
-            ``,
-            `  My branch: ${safeMyBranch}`,
-            `  Your branch: ${safeBranch}`,
-            ``,
-            `Conflicting files: ${fileList}${more}`,
-            ``,
-            `Action needed:`,
-            `  1. Check your changes on these files`,
-            `  2. Coordinate with me or rebase`,
-            `  3. Run: spidersan conflicts --branch ${safeBranch}`,
-            ``,
-            `Let's sync up! 🕷️`
-        ].join('\n');
-        // Security: Use execFileSync with argument array instead of string interpolation
-        execFileSync('mycmail', ['send', safeAgentId, subject, '-m', body], {
-            encoding: 'utf-8',
-            stdio: 'pipe'
-        });
-        console.log(`  📧 Message sent to ${agentId}`);
-        return true;
-    }
-    catch {
-        console.log(`  ⚠️ Could not send mycmail to ${agentId}`);
-        return false;
-    }
-}
+import { TIER_LABELS } from '../lib/conflict-tier.js';
+import { createHubClient } from '../lib/hub.js';
+const hub = createHubClient();
 /**
  * Wait for a specified time
  */
 function sleep(ms) {
     return new Promise(resolve => setTimeout(resolve, ms));
 }
-/**
- * Suggest simple resolutions for add/add style conflicts where both branches added the same file
- * Typically occurs with docs or generated files. This prints guidance and a recommended sequence
- * to preserve both variants for auditability (e.g., create a .incoming copy).
- */
-function suggestAddAddResolution(conflicts) {
-    const addAddFiles = new Set();
-    for (const conflict of conflicts) {
-        for (const f of conflict.files) {
-            // Simple heuristic: docs and markdown files are common add/add candidates
-            if (/\.md$/.test(f) || /docs\//.test(f)) {
-                addAddFiles.add(f);
-            }
-        }
-    }
-    if (addAddFiles.size === 0)
-        return;
-    console.log('\n💡 Add/Add Conflict Helper');
-    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
-    console.log('Detected files added in both branches. Recommended actions:');
-    console.log('  1. Preserve incoming variant for auditability:');
-    console.log('       git checkout --theirs <file> && mv <file> <file>.<their-branch>.incoming && git add <file>.<their-branch>.incoming');
-    console.log('  2. Keep canonical version in main branch and include note linking the incoming variant.');
-    console.log('  3. Commit and continue rebase: git add -A && git rebase --continue');
-    console.log('\nExamples:');
-    for (const f of addAddFiles) {
-        console.log(`   • ${f} -> preserve incoming as ${f}.incoming`);
-    }
-    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
+function writeStdout(message = '') {
+    process.stdout.write(`${message}\n`);
+}
+function writeStderr(message) {
+    process.stderr.write(`${message}\n`);
+}
+function fail(messages) {
+    const output = Array.isArray(messages) ? messages.join('\n') : messages;
+    writeStderr(output);
+    process.exit(1);
 }
 /**
  * Prompt user for Y/N confirmation (prevents Ralph Wiggum loops)
@@ -211,7 +49,7 @@ function suggestAddAddResolution(conflicts) {
  */
 async function confirmAction(prompt, autoConfirm = false) {
     if (autoConfirm) {
-        console.log(`${prompt} [Y/n]: Y (auto)`);
+        writeStdout(`${prompt} [Y/n]: Y (auto)`);
         return true;
     }
     const readline = await import('readline');
@@ -227,6 +65,141 @@ async function confirmAction(prompt, autoConfirm = false) {
         });
     });
 }
+function filterConflictReport(report, minTier) {
+    const conflicts = report.conflicts.filter((conflict) => conflict.tier >= minTier);
+    const byTier = {
+        1: conflicts.filter((conflict) => conflict.tier === 1),
+        2: conflicts.filter((conflict) => conflict.tier === 2),
+        3: conflicts.filter((conflict) => conflict.tier === 3),
+    };
+    const highest = conflicts.length > 0
+        ? conflicts.reduce((max, conflict) => (conflict.tier > max ? conflict.tier : max), 1)
+        : 1;
+    return {
+        conflicts,
+        byTier,
+        highest,
+        shouldBlock: highest === 3,
+    };
+}
+function buildBranchConflicts(report) {
+    const branchOrder = inferBranchOrder(report);
+    const branchOrderIndex = new Map(branchOrder.map((branch, index) => [branch, index]));
+    const grouped = new Map();
+    for (const conflict of report.conflicts) {
+        for (const branch of conflict.branches) {
+            let entry = grouped.get(branch.name);
+            if (!entry) {
+                entry = {
+                    branch: branch.name,
+                    files: [],
+                    tier: 1,
+                    tierInfo: TIER_LABELS[1],
+                };
+                grouped.set(branch.name, entry);
+            }
+            if (!entry.files.includes(conflict.file)) {
+                entry.files.push(conflict.file);
+            }
+            if (conflict.tier > entry.tier) {
+                entry.tier = conflict.tier;
+                entry.tierInfo = TIER_LABELS[conflict.tier];
+            }
+        }
+    }
+    return [...grouped.values()].sort((left, right) => {
+        if (right.tier !== left.tier) {
+            return right.tier - left.tier;
+        }
+        return (branchOrderIndex.get(left.branch) ?? Number.MAX_SAFE_INTEGER)
+            - (branchOrderIndex.get(right.branch) ?? Number.MAX_SAFE_INTEGER);
+    });
+}
+function inferBranchOrder(report) {
+    const adjacency = new Map();
+    const indegree = new Map();
+    const firstSeen = new Map();
+    let seenIndex = 0;
+    const ensureBranch = (branch) => {
+        if (!adjacency.has(branch)) {
+            adjacency.set(branch, new Set());
+        }
+        if (!indegree.has(branch)) {
+            indegree.set(branch, 0);
+        }
+        if (!firstSeen.has(branch)) {
+            firstSeen.set(branch, seenIndex++);
+        }
+    };
+    for (const conflict of report.conflicts) {
+        const branchNames = conflict.branches.map((branch) => branch.name);
+        for (const branch of branchNames) {
+            ensureBranch(branch);
+        }
+        for (let index = 0; index < branchNames.length; index++) {
+            for (let nextIndex = index + 1; nextIndex < branchNames.length; nextIndex++) {
+                const from = branchNames[index];
+                const to = branchNames[nextIndex];
+                const edges = adjacency.get(from);
+                if (!edges || edges.has(to)) {
+                    continue;
+                }
+                edges.add(to);
+                indegree.set(to, (indegree.get(to) ?? 0) + 1);
+            }
+        }
+    }
+    const queue = [...indegree.entries()]
+        .filter(([, degree]) => degree === 0)
+        .map(([branch]) => branch)
+        .sort((left, right) => (firstSeen.get(left) ?? 0) - (firstSeen.get(right) ?? 0));
+    const ordered = [];
+    while (queue.length > 0) {
+        const branch = queue.shift();
+        if (!branch) {
+            break;
+        }
+        ordered.push(branch);
+        for (const next of adjacency.get(branch) ?? []) {
+            const nextDegree = (indegree.get(next) ?? 0) - 1;
+            indegree.set(next, nextDegree);
+            if (nextDegree === 0) {
+                queue.push(next);
+                queue.sort((left, right) => (firstSeen.get(left) ?? 0) - (firstSeen.get(right) ?? 0));
+            }
+        }
+    }
+    if (ordered.length === indegree.size) {
+        return ordered;
+    }
+    return [...firstSeen.entries()]
+        .sort((left, right) => left[1] - right[1])
+        .map(([branch]) => branch);
+}
+function countByTier(report) {
+    const conflicts = buildBranchConflicts(report);
+    return {
+        tier1: conflicts.filter((conflict) => conflict.tier === 1).length,
+        tier2: conflicts.filter((conflict) => conflict.tier === 2).length,
+        tier3: conflicts.filter((conflict) => conflict.tier === 3).length,
+    };
+}
+function createJsonReport(report, branch, blocked) {
+    const summary = countByTier(report);
+    return {
+        ...report,
+        branch,
+        conflicts: report.conflicts.map((conflict) => ({
+            ...conflict,
+            files: [conflict.file],
+            branch: conflict.branches[0]?.name,
+        })),
+        summary: {
+            ...summary,
+            blocked,
+        },
+    };
+}
 // ── Ecosystem scan ────────────────────────────────────────────────────────────
 /**
  * Default ecosystem repos. Configurable via SPIDERSAN_ECOSYSTEM env var.
@@ -307,41 +280,42 @@ function runEcosystemScan(repos, asJson) {
     const totals = results.reduce((acc, r) => ({ tier3: acc.tier3 + r.tier3, tier2: acc.tier2 + r.tier2, tier1: acc.tier1 + r.tier1 }), { tier3: 0, tier2: 0, tier1: 0 });
     const reposWithConflicts = results.filter(r => r.tier3 + r.tier2 + r.tier1 > 0).length;
     if (asJson) {
-        console.log(JSON.stringify({
+        writeStdout(JSON.stringify({
             ecosystem: true,
             repos: results,
             summary: { ...totals, repos_scanned: results.length, repos_with_conflicts: reposWithConflicts },
         }, null, 2));
         return;
     }
-    console.log(`
+    writeStdout(`
 🕷️  ECOSYSTEM CONFLICT SCAN
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 `);
     for (const r of results) {
         if (r.skipped) {
-            console.log(`  ⬜ ${r.name.padEnd(22)} (not initialized)`);
+            writeStdout(`  ⬜ ${r.name.padEnd(22)} (not initialized)`);
             continue;
         }
         if (r.error) {
-            console.log(`  ❓ ${r.name.padEnd(22)} (${r.error})`);
+            writeStdout(`  ❓ ${r.name.padEnd(22)} (${r.error})`);
             continue;
         }
         const icon = r.tier3 > 0 ? '🔴' : r.tier2 > 0 ? '🟠' : r.tier1 > 0 ? '🟡' : '✅';
         const counts = r.tier3 + r.tier2 + r.tier1 > 0
             ? `  T3:${r.tier3} T2:${r.tier2} T1:${r.tier1}`
             : '  clean';
-        console.log(`  ${icon} ${r.name.padEnd(22)}${counts}`);
+        writeStdout(`  ${icon} ${r.name.padEnd(22)}${counts}`);
     }
-    console.log(`\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`);
-    console.log(`📊 Total: 🔴 ${totals.tier3} BLOCK | 🟠 ${totals.tier2} PAUSE | 🟡 ${totals.tier1} WARN`);
-    console.log(`   Repos scanned: ${results.length} | With conflicts: ${reposWithConflicts}`);
+    writeStdout('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+    writeStdout(`📊 Total: 🔴 ${totals.tier3} BLOCK | 🟠 ${totals.tier2} PAUSE | 🟡 ${totals.tier1} WARN`);
+    writeStdout(`   Repos scanned: ${results.length} | With conflicts: ${reposWithConflicts}`);
 }
 export const conflictsCommand = new Command('conflicts')
     .description('Detect file conflicts between branches (with tiered blocking)')
     .option('--branch <name>', 'Check conflicts for specific branch')
     .option('--pr <number>', 'Check conflicts for a GitHub pull request by number')
     .option('--json', 'Output as JSON')
+    .option('--verbose', 'Show detailed symbol overlap information in human output')
     .option('--tier <level>', 'Filter by minimum tier (1, 2, or 3)', '1')
     .option('--strict', 'Strict mode: exit with error if TIER 2+ conflicts found')
     .option('--notify', 'Notify Hub of TIER 2+ conflicts')
@@ -364,26 +338,27 @@ export const conflictsCommand = new Command('conflicts')
     const storage = await getStorage();
     const config = await loadConfig();
     if (!await storage.isInitialized()) {
-        console.error('❌ Spidersan not initialized. Run: spidersan init');
-        process.exit(1);
+        fail('❌ Spidersan not initialized. Run: spidersan init');
     }
     const minTier = parseInt(options.tier, 10);
     // Load custom patterns from config
     const highSeverity = (config.conflicts?.highSeverityPatterns || []).map(p => new RegExp(p));
     const mediumSeverity = (config.conflicts?.mediumSeverityPatterns || []).map(p => new RegExp(p));
+    const compiledHigh = compilePatterns(highSeverity);
+    const compiledMedium = compilePatterns(mediumSeverity);
     let targetBranch;
     let targetFiles;
     if (options.pr) {
         // --pr mode: fetch PR head branch + changed files from GitHub
         const prNumber = parseInt(options.pr, 10);
         if (isNaN(prNumber) || prNumber <= 0) {
-            console.error('❌ Invalid PR number. Provide a positive integer, e.g. --pr 42');
-            process.exit(1);
+            fail('❌ Invalid PR number. Provide a positive integer, e.g. --pr 42');
         }
         if (!isGhAvailable()) {
-            console.error('❌ GitHub CLI (gh) is not available or not authenticated.');
-            console.error('   Install: https://cli.github.com  →  gh auth login');
-            process.exit(1);
+            fail([
+                '❌ GitHub CLI (gh) is not available or not authenticated.',
+                '   Install: https://cli.github.com  →  gh auth login',
+            ]);
         }
         let prDetails;
         try {
@@ -391,58 +366,47 @@ export const conflictsCommand = new Command('conflicts')
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
-            console.error(`❌ Failed to fetch PR #${prNumber}: ${msg}`);
-            process.exit(1);
+            fail(`❌ Failed to fetch PR #${prNumber}: ${msg}`);
         }
         targetBranch = prDetails.headBranch;
         targetFiles = prDetails.files;
-        console.log(`🕷️ Checking conflicts for PR #${prNumber}: "${prDetails.title}"`);
-        console.log(`   Branch: ${targetBranch} (${targetFiles.length} file(s) changed)`);
+        writeStdout(`🕷️ Checking conflicts for PR #${prNumber}: "${prDetails.title}"`);
+        writeStdout(`   Branch: ${targetBranch} (${targetFiles.length} file(s) changed)`);
     }
     else {
         // Normal --branch or current branch mode
         targetBranch = options.branch || getCurrentBranch();
         const target = await storage.get(targetBranch);
         if (!target) {
-            console.error(`❌ Branch "${targetBranch}" is not registered.`);
-            console.error('   Run: spidersan register --files "..."');
-            process.exit(1);
+            fail([
+                `❌ Branch "${targetBranch}" is not registered.`,
+                '   Run: spidersan register --files "..."',
+            ]);
         }
         targetFiles = target.files;
     }
     const allBranches = await storage.list();
-    const conflicts = [];
-    // Performance Optimization: Convert target files to Set for O(1) lookup
-    // Reduces complexity from O(N*M*K) to O(N*M) where N=branches, M=files/branch, K=target_files
-    // Filter excluded paths (node_modules/, dist/, etc.) at query time to handle stale registrations
-    const targetFilesSet = new Set(targetFiles.filter(f => !isExcludedPath(f)));
-    for (const branch of allBranches) {
-        if (branch.name === targetBranch || branch.status !== 'active')
-            continue;
-        const overlappingFiles = branch.files.filter(f => !isExcludedPath(f) && targetFilesSet.has(f));
-        if (overlappingFiles.length > 0) {
-            // Get highest tier for this conflict
-            let maxTier = { tier: 1, label: 'WARN', icon: '🟡', action: '' };
-            for (const file of overlappingFiles) {
-                const fileTier = getConflictTier(file, highSeverity, mediumSeverity);
-                if (fileTier.tier > maxTier.tier) {
-                    maxTier = fileTier;
-                }
-            }
-            if (maxTier.tier >= minTier) {
-                conflicts.push({
-                    branch: branch.name,
-                    files: overlappingFiles,
-                    tier: maxTier.tier,
-                    tierInfo: maxTier
-                });
-            }
-        }
-    }
+    const analysisBranches = allBranches
+        .filter(branch => branch.name !== targetBranch && branch.status === 'active')
+        .map(branch => ({
+        ...branch,
+        files: branch.files.filter(file => !isExcludedPath(file)),
+    }));
+    const rawReport = analyzeConflicts({
+        branches: analysisBranches,
+        targetFiles: targetFiles.filter(file => !isExcludedPath(file)),
+        options: {
+            extraTier3: compiledHigh,
+            extraTier2: compiledMedium,
+            useSymbolAware: false,
+        },
+    });
+    const report = filterConflictReport(rawReport, minTier);
+    const conflicts = buildBranchConflicts(report);
     // SEMANTIC ANALYSIS with AST parser
     const semanticConflicts = [];
     if (options.semantic && conflicts.length > 0) {
-        console.log('\n🔬 Running semantic (AST) analysis...');
+        writeStdout('\n🔬 Running semantic (AST) analysis...');
         const astParser = new ASTParser();
         for (const conflict of conflicts) {
             for (const file of conflict.files) {
@@ -450,10 +414,11 @@ export const conflictsCommand = new Command('conflicts')
                 if (!/\.(ts|js|tsx|jsx)$/.test(file))
                     continue;
                 try {
-                    // Get file content from both branches
-                    // Security: Use execFileSync to prevent command injection via file names
-                    const currentContent = execFileSync('git', ['show', `HEAD:${file}`], { encoding: 'utf-8' });
-                    const otherContent = execFileSync('git', ['show', `${conflict.branch}:${file}`], { encoding: 'utf-8' });
+                    const currentContent = getFileAtRef('HEAD', file);
+                    const otherContent = getFileAtRef(conflict.branch, file);
+                    if (currentContent === null || otherContent === null) {
+                        continue;
+                    }
                     const symbolConflicts = astParser.findSymbolConflicts(currentContent, `${targetBranch}:${file}`, otherContent, `${conflict.branch}:${file}`);
                     semanticConflicts.push(...symbolConflicts);
                 }
@@ -463,95 +428,75 @@ export const conflictsCommand = new Command('conflicts')
             }
         }
     }
-    // Sort by tier (highest first)
-    conflicts.sort((a, b) => b.tier - a.tier);
     // Log conflict detection to activity log
     if (conflicts.length > 0) {
-        logActivity({
-            event: 'conflict_detected',
-            branch: targetBranch,
-            details: {
-                tier3: conflicts.filter(c => c.tier === 3).length,
-                tier2: conflicts.filter(c => c.tier === 2).length,
-                tier1: conflicts.filter(c => c.tier === 1).length,
-                conflicting_branches: conflicts.map(c => c.branch),
-            }
-        });
+        try {
+            const summary = countByTier(report);
+            logActivity({
+                event: 'conflict_detected',
+                branch: targetBranch,
+                details: {
+                    tier3: summary.tier3,
+                    tier2: summary.tier2,
+                    tier1: summary.tier1,
+                    conflicting_branches: conflicts.map(c => c.branch),
+                }
+            });
+        }
+        catch {
+            // Telemetry should never block conflict detection.
+        }
     }
     // Check for blocking conditions
-    const tier3Count = conflicts.filter(c => c.tier === 3).length;
-    const tier2Count = conflicts.filter(c => c.tier === 2).length;
+    const { tier2: tier2Count, tier3: tier3Count } = countByTier(report);
     const shouldBlock = options.strict && (tier3Count > 0 || tier2Count > 0);
     // Notify Hub if requested
     if (options.notify && (tier3Count > 0 || tier2Count > 0)) {
-        await notifyHub(targetBranch, conflicts);
+        await hub.notifyConflict(targetBranch, conflicts);
     }
     if (options.json) {
-        console.log(JSON.stringify({
-            branch: targetBranch,
-            conflicts,
-            summary: {
-                tier3: tier3Count,
-                tier2: tier2Count,
-                tier1: conflicts.filter(c => c.tier === 1).length,
-                blocked: shouldBlock
-            }
-        }, null, 2));
+        console.log(JSON.stringify(createJsonReport(report, targetBranch, shouldBlock), null, 2));
         if (shouldBlock)
             process.exit(1);
         return;
     }
-    if (conflicts.length === 0) {
-        console.log(`🕷️ No conflicts detected for "${targetBranch}"`);
-        console.log('   ✅ You\'re good to merge!');
-        return;
-    }
-    console.log(`
+    const renderedReport = renderConflictReport(report, { verbose: !!options.verbose });
+    const humanOutput = conflicts.length === 0
+        ? renderedReport.replace('🕷️ No conflicts detected', `🕷️ No conflicts detected for "${targetBranch}"`)
+        : `
 🕷️ CONFLICT ANALYSIS: "${targetBranch}"
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-        `);
-    for (const conflict of conflicts) {
-        console.log(`${conflict.tierInfo.icon} TIER ${conflict.tier} (${conflict.tierInfo.label}): ${conflict.branch}`);
-        for (const file of conflict.files) {
-            const fileTier = getConflictTier(file, highSeverity, mediumSeverity);
-            console.log(`   ${fileTier.icon} ${file}`);
-        }
-        console.log(`   → ${conflict.tierInfo.action}`);
-        console.log('');
-    }
-    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
-    console.log(`📊 Summary: 🔴 ${tier3Count} BLOCK | 🟠 ${tier2Count} PAUSE | 🟡 ${conflicts.filter(c => c.tier === 1).length} WARN`);
-    // Offer add/add resolution suggestions for likely add/add files
-    suggestAddAddResolution(conflicts);
+        
+${renderedReport}`;
+    console.log(humanOutput);
     // Show semantic analysis results
     if (options.semantic && semanticConflicts.length > 0) {
-        console.log(`\n🔬 SEMANTIC CONFLICTS DETECTED (${semanticConflicts.length} symbols):`);
-        console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+        writeStdout(`\n🔬 SEMANTIC CONFLICTS DETECTED (${semanticConflicts.length} symbols):`);
+        writeStdout('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
         for (const sc of semanticConflicts) {
-            console.log(`  ⚡ ${sc.symbolType} '${sc.symbolName}'`);
-            console.log(`     Modified in BOTH branches (different content)`);
+            writeStdout(`  ⚡ ${sc.symbolType} '${sc.symbolName}'`);
+            writeStdout('     Modified in BOTH branches (different content)');
         }
-        console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
-        console.log('\n💡 TIP: Coordinate on these specific functions/classes,');
-        console.log('   not just the files. One of you should rebase.');
+        writeStdout('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+        writeStdout('\n💡 TIP: Coordinate on these specific functions/classes,');
+        writeStdout('   not just the files. One of you should rebase.');
     }
     else if (options.semantic && semanticConflicts.length === 0) {
-        console.log('\n🔬 SEMANTIC ANALYSIS: No symbol-level conflicts!');
-        console.log('   Files overlap, but different functions were modified.');
-        console.log('   ✅ Likely safe to merge (git will auto-merge).');
+        writeStdout('\n🔬 SEMANTIC ANALYSIS: No symbol-level conflicts!');
+        writeStdout('   Files overlap, but different functions were modified.');
+        writeStdout('   ✅ Likely safe to merge (git will auto-merge).');
     }
     if (tier3Count > 0) {
-        console.log(`
+        writeStdout(`
 🔴 TIER 3 CONFLICTS FOUND
    These files are security-critical and MUST be resolved.
    Merge is BLOCKED until conflicts are cleared.
             `);
     }
     else if (tier2Count > 0) {
-        console.log(`
+        writeStdout(`
 🟠 TIER 2 CONFLICTS FOUND
    Coordinate with the other agent before proceeding.
-   Use: mycmail send <agent> "Need to sync on <file>"
             `);
     }
     // Wake conflicting agents if --wake flag is set
@@ -569,61 +514,67 @@ export const conflictsCommand = new Command('conflicts')
             }
         }
         if (agentsToWake.size === 0) {
-            console.log('\n⚠️ No agents registered on conflicting branches.');
+            writeStdout('\n⚠️ No agents registered on conflicting branches.');
         }
         else {
             // Show what will happen and ask for confirmation
-            console.log('\n🔔 WAKE AGENTS?');
-            console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+            writeStdout('\n🔔 WAKE AGENTS?');
+            writeStdout('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
             for (const [agent, info] of agentsToWake) {
-                console.log(`  • ${agent} (${info.branch})`);
+                writeStdout(`  • ${agent} (${info.branch})`);
             }
-            console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
-            console.log('This will:');
-            console.log('  1. Send wake signal via Hub');
-            console.log('  2. Send mycmail with conflict details\n');
+            writeStdout('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+            writeStdout('This will:');
+            writeStdout('  1. Send wake signal via Hub\n');
             const confirmed = await confirmAction('Wake these agents?', options.auto);
             if (confirmed) {
-                console.log('\n🔔 WAKING AGENTS...\n');
+                writeStdout('\n🔔 WAKING AGENTS...\n');
                 for (const [agentId, info] of agentsToWake) {
-                    await wakeConflictingAgent(agentId, targetBranch, info.branch, info.files);
+                    const woke = await hub.wakeAgent(agentId, `Conflict on ${info.branch} - need resolution`);
+                    if (woke) {
+                        writeStdout(`  🔔 Wake signal sent to ${agentId}`);
+                    }
+                    else {
+                        writeStdout(`  ⚠️ Could not wake ${agentId} via Hub`);
+                    }
                 }
-                console.log(`\n✅ Woke ${agentsToWake.size} agent(s)`);
+                writeStdout(`\n✅ Woke ${agentsToWake.size} agent(s)`);
                 // If --retry is set, ask before waiting
                 if (options.retry) {
                     const waitSeconds = parseInt(options.retry, 10);
                     const retryConfirmed = await confirmAction(`\nWait ${waitSeconds}s and re-check conflicts?`, options.auto);
                     if (retryConfirmed) {
-                        console.log(`\n⏳ Waiting ${waitSeconds}s for agents to resolve conflicts...`);
+                        writeStdout(`\n⏳ Waiting ${waitSeconds}s for agents to resolve conflicts...`);
                         await sleep(waitSeconds * 1000);
-                        console.log('\n🔄 RE-CHECKING CONFLICTS...\n');
+                        writeStdout('\n🔄 RE-CHECKING CONFLICTS...\n');
                         const { execFileSync } = await import('child_process');
                         try {
+                            const { getCLIPath } = await import('../lib/security.js');
                             // Security: Use execFileSync with argument array
                             const safeBranch = validateBranchName(targetBranch);
                             const tierArg = String(parseInt(options.tier, 10) || 1);
-                            execFileSync('node', [process.argv[1], 'conflicts', '--branch', safeBranch, '--tier', tierArg], {
+                            execFileSync(process.execPath, [getCLIPath(), 'conflicts', '--branch', safeBranch, '--tier', tierArg], {
                                 encoding: 'utf-8',
                                 stdio: 'inherit'
                             });
                             return;
                         }
                         catch {
-                            console.log('❌ Conflicts still exist after retry.');
+                            writeStdout('❌ Conflicts still exist after retry.');
                         }
                     }
                     else {
-                        console.log('⏭️ Skipping retry.');
+                        writeStdout('⏭️ Skipping retry.');
                     }
                 }
             }
             else {
-                console.log('⏭️ Skipping wake.');
+                writeStdout('⏭️ Skipping wake.');
             }
         }
     }
     if (shouldBlock) {
-        console.log('❌ Strict mode: Exiting with error due to TIER 2+ conflicts.');
+        writeStdout('❌ Strict mode: Exiting with error due to TIER 2+ conflicts.');
         process.exit(1);
     }
 });