spidersan 0.9.0 → 0.10.0

package/dist/commands/conflicts.js

@@ -9,38 +9,116 @@
  */
 import { Command } from 'commander';
 import { compilePatterns } from '../lib/regex-utils.js';
-import { spawnSync } from 'child_process';
+import { execFileSync, 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 { 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';
-import { TIER_LABELS } from '../lib/conflict-tier.js';
-import { createHubClient } from '../lib/hub.js';
-const hub = createHubClient();
+import { classifyWithLabel } from '../lib/conflict-tier.js';
+// Config
+const HUB_URL = process.env.HUB_URL || 'https://hub.treebird.uk';
+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) {
+    let hasTier3 = false;
+    let hasTier2 = false;
+    for (const c of conflicts) {
+        if (c.tier === 3)
+            hasTier3 = true;
+        else if (c.tier === 2)
+            hasTier2 = true;
+        if (hasTier3 && hasTier2)
+            break;
+    }
+    if (!hasTier3 && !hasTier2)
+        return;
+    const severity = hasTier3 ? '🔴 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) {
+    // 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`);
+    }
+    return true;
+}
 /**
  * Wait for a specified time
  */
 function sleep(ms) {
     return new Promise(resolve => setTimeout(resolve, ms));
 }
-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);
+/**
+ * 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');
 }
 /**
  * Prompt user for Y/N confirmation (prevents Ralph Wiggum loops)
@@ -49,7 +127,7 @@ function fail(messages) {
  */
 async function confirmAction(prompt, autoConfirm = false) {
     if (autoConfirm) {
-        writeStdout(`${prompt} [Y/n]: Y (auto)`);
+        console.log(`${prompt} [Y/n]: Y (auto)`);
         return true;
     }
     const readline = await import('readline');
@@ -65,141 +143,6 @@ 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.
@@ -280,42 +223,41 @@ 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) {
-        writeStdout(JSON.stringify({
+        console.log(JSON.stringify({
             ecosystem: true,
             repos: results,
             summary: { ...totals, repos_scanned: results.length, repos_with_conflicts: reposWithConflicts },
         }, null, 2));
         return;
     }
-    writeStdout(`
+    console.log(`
 🕷️  ECOSYSTEM CONFLICT SCAN
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 `);
     for (const r of results) {
         if (r.skipped) {
-            writeStdout(`  ⬜ ${r.name.padEnd(22)} (not initialized)`);
+            console.log(`  ⬜ ${r.name.padEnd(22)} (not initialized)`);
             continue;
         }
         if (r.error) {
-            writeStdout(`  ❓ ${r.name.padEnd(22)} (${r.error})`);
+            console.log(`  ❓ ${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';
-        writeStdout(`  ${icon} ${r.name.padEnd(22)}${counts}`);
+        console.log(`  ${icon} ${r.name.padEnd(22)}${counts}`);
     }
-    writeStdout('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
-    writeStdout(`📊 Total: 🔴 ${totals.tier3} BLOCK | 🟠 ${totals.tier2} PAUSE | 🟡 ${totals.tier1} WARN`);
-    writeStdout(`   Repos scanned: ${results.length} | With conflicts: ${reposWithConflicts}`);
+    console.log(`\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`);
+    console.log(`📊 Total: 🔴 ${totals.tier3} BLOCK | 🟠 ${totals.tier2} PAUSE | 🟡 ${totals.tier1} WARN`);
+    console.log(`   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')
@@ -338,7 +280,8 @@ export const conflictsCommand = new Command('conflicts')
     const storage = await getStorage();
     const config = await loadConfig();
     if (!await storage.isInitialized()) {
-        fail('❌ Spidersan not initialized. Run: spidersan init');
+        console.error('❌ Spidersan not initialized. Run: spidersan init');
+        process.exit(1);
     }
     const minTier = parseInt(options.tier, 10);
     // Load custom patterns from config
@@ -352,13 +295,13 @@ export const conflictsCommand = new Command('conflicts')
         // --pr mode: fetch PR head branch + changed files from GitHub
         const prNumber = parseInt(options.pr, 10);
         if (isNaN(prNumber) || prNumber <= 0) {
-            fail('❌ Invalid PR number. Provide a positive integer, e.g. --pr 42');
+            console.error('❌ Invalid PR number. Provide a positive integer, e.g. --pr 42');
+            process.exit(1);
         }
         if (!isGhAvailable()) {
-            fail([
-                '❌ GitHub CLI (gh) is not available or not authenticated.',
-                '   Install: https://cli.github.com  →  gh auth login',
-            ]);
+            console.error('❌ GitHub CLI (gh) is not available or not authenticated.');
+            console.error('   Install: https://cli.github.com  →  gh auth login');
+            process.exit(1);
         }
         let prDetails;
         try {
@@ -366,47 +309,69 @@ export const conflictsCommand = new Command('conflicts')
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
-            fail(`❌ Failed to fetch PR #${prNumber}: ${msg}`);
+            console.error(`❌ Failed to fetch PR #${prNumber}: ${msg}`);
+            process.exit(1);
         }
         targetBranch = prDetails.headBranch;
         targetFiles = prDetails.files;
-        writeStdout(`🕷️ Checking conflicts for PR #${prNumber}: "${prDetails.title}"`);
-        writeStdout(`   Branch: ${targetBranch} (${targetFiles.length} file(s) changed)`);
+        console.log(`🕷️ Checking conflicts for PR #${prNumber}: "${prDetails.title}"`);
+        console.log(`   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) {
-            fail([
-                `❌ Branch "${targetBranch}" is not registered.`,
-                '   Run: spidersan register --files "..."',
-            ]);
+            console.error(`❌ Branch "${targetBranch}" is not registered.`);
+            console.error('   Run: spidersan register --files "..."');
+            process.exit(1);
         }
         targetFiles = target.files;
     }
     const allBranches = await storage.list();
-    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);
+    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;
+        // Performance Optimization: Replace .filter() with a standard loop to avoid array allocation.
+        // Short-circuit using O(1) Set lookup (targetFilesSet.has) before calling the expensive isExcludedPath.
+        const overlappingFiles = [];
+        for (let i = 0; i < branch.files.length; i++) {
+            const f = branch.files[i];
+            if (targetFilesSet.has(f) && !isExcludedPath(f)) {
+                overlappingFiles.push(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 = classifyWithLabel(file, {
+                    extraTier3: compiledHigh,
+                    extraTier2: compiledMedium,
+                });
+                if (fileTier.tier > maxTier.tier) {
+                    maxTier = fileTier;
+                }
+            }
+            if (maxTier.tier >= minTier) {
+                conflicts.push({
+                    branch: branch.name,
+                    files: overlappingFiles,
+                    tier: maxTier.tier,
+                    tierInfo: maxTier
+                });
+            }
+        }
+    }
     // SEMANTIC ANALYSIS with AST parser
     const semanticConflicts = [];
     if (options.semantic && conflicts.length > 0) {
-        writeStdout('\n🔬 Running semantic (AST) analysis...');
+        console.log('\n🔬 Running semantic (AST) analysis...');
         const astParser = new ASTParser();
         for (const conflict of conflicts) {
             for (const file of conflict.files) {
@@ -414,11 +379,10 @@ export const conflictsCommand = new Command('conflicts')
                 if (!/\.(ts|js|tsx|jsx)$/.test(file))
                     continue;
                 try {
-                    const currentContent = getFileAtRef('HEAD', file);
-                    const otherContent = getFileAtRef(conflict.branch, file);
-                    if (currentContent === null || otherContent === null) {
-                        continue;
-                    }
+                    // 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 symbolConflicts = astParser.findSymbolConflicts(currentContent, `${targetBranch}:${file}`, otherContent, `${conflict.branch}:${file}`);
                     semanticConflicts.push(...symbolConflicts);
                 }
@@ -428,73 +392,104 @@ export const conflictsCommand = new Command('conflicts')
             }
         }
     }
+    // Sort by tier (highest first)
+    conflicts.sort((a, b) => b.tier - a.tier);
+    let tier3Count = 0;
+    let tier2Count = 0;
+    let tier1Count = 0;
+    for (const c of conflicts) {
+        if (c.tier === 3)
+            tier3Count++;
+        else if (c.tier === 2)
+            tier2Count++;
+        else if (c.tier === 1)
+            tier1Count++;
+    }
     // Log conflict detection to activity log
     if (conflicts.length > 0) {
-        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.
-        }
+        logActivity({
+            event: 'conflict_detected',
+            branch: targetBranch,
+            details: {
+                tier3: tier3Count,
+                tier2: tier2Count,
+                tier1: tier1Count,
+                conflicting_branches: conflicts.map(c => c.branch),
+            }
+        });
     }
     // Check for blocking conditions
-    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 hub.notifyConflict(targetBranch, conflicts);
+        await notifyHub(targetBranch, conflicts);
     }
     if (options.json) {
-        console.log(JSON.stringify(createJsonReport(report, targetBranch, shouldBlock), null, 2));
+        console.log(JSON.stringify({
+            branch: targetBranch,
+            conflicts,
+            summary: {
+                tier3: tier3Count,
+                tier2: tier2Count,
+                tier1: tier1Count,
+                blocked: shouldBlock
+            }
+        }, null, 2));
         if (shouldBlock)
             process.exit(1);
         return;
     }
-    const renderedReport = renderConflictReport(report, { verbose: !!options.verbose });
-    const humanOutput = conflicts.length === 0
-        ? renderedReport.replace('🕷️ No conflicts detected', `🕷️ No conflicts detected for "${targetBranch}"`)
-        : `
+    if (conflicts.length === 0) {
+        console.log(`🕷️ No conflicts detected for "${targetBranch}"`);
+        console.log('   ✅ You\'re good to merge!');
+        return;
+    }
+    console.log(`
 🕷️ CONFLICT ANALYSIS: "${targetBranch}"
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-        
-${renderedReport}`;
-    console.log(humanOutput);
+        `);
+    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 = classifyWithLabel(file, {
+                extraTier3: compiledHigh,
+                extraTier2: compiledMedium,
+            });
+            console.log(`   ${fileTier.icon} ${file}`);
+        }
+        console.log(`   → ${conflict.tierInfo.action}`);
+        console.log('');
+    }
+    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+    console.log(`📊 Summary: 🔴 ${tier3Count} BLOCK | 🟠 ${tier2Count} PAUSE | 🟡 ${tier1Count} WARN`);
+    // Offer add/add resolution suggestions for likely add/add files
+    suggestAddAddResolution(conflicts);
     // Show semantic analysis results
     if (options.semantic && semanticConflicts.length > 0) {
-        writeStdout(`\n🔬 SEMANTIC CONFLICTS DETECTED (${semanticConflicts.length} symbols):`);
-        writeStdout('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+        console.log(`\n🔬 SEMANTIC CONFLICTS DETECTED (${semanticConflicts.length} symbols):`);
+        console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
         for (const sc of semanticConflicts) {
-            writeStdout(`  ⚡ ${sc.symbolType} '${sc.symbolName}'`);
-            writeStdout('     Modified in BOTH branches (different content)');
+            console.log(`  ⚡ ${sc.symbolType} '${sc.symbolName}'`);
+            console.log(`     Modified in BOTH branches (different content)`);
         }
-        writeStdout('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
-        writeStdout('\n💡 TIP: Coordinate on these specific functions/classes,');
-        writeStdout('   not just the files. One of you should rebase.');
+        console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+        console.log('\n💡 TIP: Coordinate on these specific functions/classes,');
+        console.log('   not just the files. One of you should rebase.');
     }
     else if (options.semantic && semanticConflicts.length === 0) {
-        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).');
+        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).');
     }
     if (tier3Count > 0) {
-        writeStdout(`
+        console.log(`
 🔴 TIER 3 CONFLICTS FOUND
    These files are security-critical and MUST be resolved.
    Merge is BLOCKED until conflicts are cleared.
             `);
     }
     else if (tier2Count > 0) {
-        writeStdout(`
+        console.log(`
 🟠 TIER 2 CONFLICTS FOUND
    Coordinate with the other agent before proceeding.
             `);
@@ -514,39 +509,33 @@ ${renderedReport}`;
             }
         }
         if (agentsToWake.size === 0) {
-            writeStdout('\n⚠️ No agents registered on conflicting branches.');
+            console.log('\n⚠️ No agents registered on conflicting branches.');
         }
         else {
             // Show what will happen and ask for confirmation
-            writeStdout('\n🔔 WAKE AGENTS?');
-            writeStdout('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+            console.log('\n🔔 WAKE AGENTS?');
+            console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
             for (const [agent, info] of agentsToWake) {
-                writeStdout(`  • ${agent} (${info.branch})`);
+                console.log(`  • ${agent} (${info.branch})`);
             }
-            writeStdout('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
-            writeStdout('This will:');
-            writeStdout('  1. Send wake signal via Hub\n');
+            console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+            console.log('This will:');
+            console.log('  1. Send wake signal via Hub\n');
             const confirmed = await confirmAction('Wake these agents?', options.auto);
             if (confirmed) {
-                writeStdout('\n🔔 WAKING AGENTS...\n');
+                console.log('\n🔔 WAKING AGENTS...\n');
                 for (const [agentId, info] of agentsToWake) {
-                    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`);
-                    }
+                    await wakeConflictingAgent(agentId, targetBranch, info.branch, info.files);
                 }
-                writeStdout(`\n✅ Woke ${agentsToWake.size} agent(s)`);
+                console.log(`\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) {
-                        writeStdout(`\n⏳ Waiting ${waitSeconds}s for agents to resolve conflicts...`);
+                        console.log(`\n⏳ Waiting ${waitSeconds}s for agents to resolve conflicts...`);
                         await sleep(waitSeconds * 1000);
-                        writeStdout('\n🔄 RE-CHECKING CONFLICTS...\n');
+                        console.log('\n🔄 RE-CHECKING CONFLICTS...\n');
                         const { execFileSync } = await import('child_process');
                         try {
                             const { getCLIPath } = await import('../lib/security.js');
@@ -560,21 +549,21 @@ ${renderedReport}`;
                             return;
                         }
                         catch {
-                            writeStdout('❌ Conflicts still exist after retry.');
+                            console.log('❌ Conflicts still exist after retry.');
                         }
                     }
                     else {
-                        writeStdout('⏭️ Skipping retry.');
+                        console.log('⏭️ Skipping retry.');
                     }
                 }
             }
             else {
-                writeStdout('⏭️ Skipping wake.');
+                console.log('⏭️ Skipping wake.');
             }
         }
     }
     if (shouldBlock) {
-        writeStdout('❌ Strict mode: Exiting with error due to TIER 2+ conflicts.');
+        console.log('❌ Strict mode: Exiting with error due to TIER 2+ conflicts.');
         process.exit(1);
     }
 });