@ekkos/cli 1.3.2 → 1.3.6

package/dist/commands/scan.js

@@ -0,0 +1,386 @@
+"use strict";
+/**
+ * ekkos scan
+ *
+ * Scans the current directory's repo structure, discovers systems,
+ * and seeds them into ekkOS system_registry via the memory API.
+ *
+ * Usage:
+ *   ekkos scan                  Scan cwd and seed registry
+ *   ekkos scan --compile        Also trigger a compile pass after seeding
+ *   ekkos scan --dry-run        Show what would be seeded without calling API
+ *   ekkos scan --path /my/repo  Scan a specific directory
+ *
+ * Reuses discovery logic from apps/memory/workers/context-compiler/registry-seed.ts
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scan = scan;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const platform_js_1 = require("../utils/platform.js");
+// ── Excluded directories ─────────────────────────────────────────────────
+const EXCLUDED_DIRS = new Set([
+    'node_modules', '.next', 'dist', 'out', 'build', '.turbo', '.cache',
+    '.git', '.github', '.vscode', '.idea', '.claude', '.windsurf',
+    'coverage', '__pycache__', '.pytest_cache', '.mypy_cache',
+    'vendor', '.vercel', '.svelte-kit', 'target', 'tmp', 'temp',
+    'logs', 'downloads', 'favicon', 'public', 'resources',
+]);
+const EXCLUDED_PREFIXES = ['.', '_'];
+// ── Domain detection ─────────────────────────────────────────────────────
+const DOMAIN_MAP = {
+    apps: 'platform',
+    packages: 'packages',
+    workers: 'workers',
+    extensions: 'extensions',
+    scripts: 'infra',
+    services: 'services',
+    lib: 'memory',
+    supabase: 'infra',
+    'mcp-servers': 'tools',
+    templates: 'tools',
+    docs: 'content',
+    content: 'content',
+    monitoring: 'infra',
+    tests: 'infra',
+    e2e: 'infra',
+    src: 'core',
+    api: 'api',
+    components: 'frontend',
+    pages: 'frontend',
+};
+function detectDomain(dirPath) {
+    const topLevel = dirPath.split('/')[0];
+    return DOMAIN_MAP[topLevel] || 'other';
+}
+// ── System ID generation ─────────────────────────────────────────────────
+function toSystemId(dirPath) {
+    return dirPath
+        .toLowerCase()
+        .replace(/\//g, '-')
+        .replace(/[^a-z0-9-]/g, '')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '')
+        .slice(0, 64);
+}
+function toHumanName(dirPath) {
+    const parts = dirPath.split('/');
+    return parts[parts.length - 1]
+        .replace(/-/g, ' ')
+        .replace(/\b\w/g, c => c.toUpperCase());
+}
+// ── Directory scanner ────────────────────────────────────────────────────
+function isIncludable(fullPath) {
+    const name = (0, path_1.basename)(fullPath);
+    if (EXCLUDED_DIRS.has(name))
+        return false;
+    if (EXCLUDED_PREFIXES.some(p => name.startsWith(p)))
+        return false;
+    // Must contain at least 1 source file or meaningful config
+    try {
+        const entries = (0, fs_1.readdirSync)(fullPath);
+        const sourceFiles = entries.filter(e => {
+            const ext = e.split('.').pop()?.toLowerCase();
+            return ['ts', 'tsx', 'js', 'jsx', 'mjs', 'py', 'rs', 'go', 'sql', 'mts'].includes(ext || '');
+        });
+        const configFiles = entries.filter(e => ['package.json', 'tsconfig.json', 'Cargo.toml', 'pyproject.toml', 'wrangler.toml', 'go.mod'].includes(e));
+        return sourceFiles.length >= 1 || configFiles.length >= 1;
+    }
+    catch {
+        return false;
+    }
+}
+// Container directories that always scan children
+const CONTAINER_DIRS = new Set([
+    'apps', 'packages', 'workers', 'extensions', 'services', 'mcp-servers',
+]);
+function scanDirectory(repoRoot, currentPath, depth, maxDepth, parentId) {
+    if (depth > maxDepth)
+        return [];
+    const results = [];
+    const relPath = (0, path_1.relative)(repoRoot, currentPath) || '.';
+    const dirName = (0, path_1.basename)(currentPath);
+    // Skip root — just descend into children
+    if (relPath === '.') {
+        let entries;
+        try {
+            entries = (0, fs_1.readdirSync)(currentPath);
+        }
+        catch {
+            return [];
+        }
+        for (const entry of entries) {
+            const full = (0, path_1.join)(currentPath, entry);
+            try {
+                if ((0, fs_1.statSync)(full).isDirectory() && !EXCLUDED_DIRS.has(entry) && !entry.startsWith('.')) {
+                    results.push(...scanDirectory(repoRoot, full, depth + 1, maxDepth, null));
+                }
+            }
+            catch { /* permission denied, etc. */ }
+        }
+        return results;
+    }
+    // Container directories (apps/, packages/, etc.) — always scan children, never register themselves
+    const isContainer = CONTAINER_DIRS.has(relPath) || CONTAINER_DIRS.has(dirName);
+    if (isContainer && depth <= 1) {
+        try {
+            const entries = (0, fs_1.readdirSync)(currentPath);
+            for (const e of entries) {
+                const full = (0, path_1.join)(currentPath, e);
+                try {
+                    if ((0, fs_1.statSync)(full).isDirectory() && !EXCLUDED_DIRS.has(e) && !e.startsWith('.')) {
+                        results.push(...scanDirectory(repoRoot, full, depth + 1, maxDepth, null));
+                    }
+                }
+                catch { /* ignore */ }
+            }
+        }
+        catch { /* ignore */ }
+        return results;
+    }
+    if (!isIncludable(currentPath))
+        return [];
+    const systemId = toSystemId(relPath);
+    const domain = detectDomain(relPath);
+    // Detect description from package.json if available
+    let description = `System at ${relPath}`;
+    const pkgPath = (0, path_1.join)(currentPath, 'package.json');
+    if ((0, fs_1.existsSync)(pkgPath)) {
+        try {
+            const pkg = JSON.parse((0, fs_1.readFileSync)(pkgPath, 'utf-8'));
+            if (pkg.description)
+                description = pkg.description;
+        }
+        catch { /* ignore */ }
+    }
+    const entry = {
+        system_id: systemId,
+        name: toHumanName(relPath),
+        description,
+        directory_path: relPath,
+        domain,
+        status: 'active',
+        parent_system_id: parentId,
+        metadata: {},
+        tags: [domain],
+        aliases: [],
+    };
+    results.push(entry);
+    // Scan subdirectories for nested systems
+    const topLevel = relPath.split('/')[0];
+    const isNestedContainer = CONTAINER_DIRS.has(topLevel);
+    if (isNestedContainer && depth <= 3) {
+        try {
+            const entries = (0, fs_1.readdirSync)(currentPath);
+            for (const e of entries) {
+                const full = (0, path_1.join)(currentPath, e);
+                try {
+                    if ((0, fs_1.statSync)(full).isDirectory() && !EXCLUDED_DIRS.has(e) && !e.startsWith('.')) {
+                        results.push(...scanDirectory(repoRoot, full, depth + 1, maxDepth, systemId));
+                    }
+                }
+                catch { /* ignore */ }
+            }
+        }
+        catch { /* ignore */ }
+    }
+    return results;
+}
+// ── Boundary Precedence ──────────────────────────────────────────────────
+function assignParentSystems(systems) {
+    const sorted = [...systems].sort((a, b) => {
+        const depthA = a.directory_path.split('/').length;
+        const depthB = b.directory_path.split('/').length;
+        if (depthA !== depthB)
+            return depthA - depthB;
+        return a.system_id.localeCompare(b.system_id);
+    });
+    for (let i = 0; i < sorted.length; i++) {
+        const system = sorted[i];
+        if (system.parent_system_id)
+            continue;
+        let nearestParent = null;
+        let nearestDepth = -1;
+        for (let j = 0; j < sorted.length; j++) {
+            if (i === j)
+                continue;
+            const candidate = sorted[j];
+            const candidateDepth = candidate.directory_path.split('/').length;
+            if (system.directory_path.startsWith(candidate.directory_path + '/') &&
+                candidateDepth > nearestDepth) {
+                nearestParent = candidate;
+                nearestDepth = candidateDepth;
+            }
+        }
+        if (nearestParent) {
+            system.parent_system_id = nearestParent.system_id;
+        }
+    }
+    return sorted;
+}
+// ── Load API key from config ─────────────────────────────────────────────
+function loadApiKey() {
+    try {
+        if ((0, fs_1.existsSync)(platform_js_1.EKKOS_CONFIG)) {
+            const config = JSON.parse((0, fs_1.readFileSync)(platform_js_1.EKKOS_CONFIG, 'utf-8'));
+            return config.apiKey || null;
+        }
+    }
+    catch { /* ignore */ }
+    // Fall back to env var
+    return process.env.EKKOS_API_KEY || null;
+}
+// ── Detect git repo root ─────────────────────────────────────────────────
+function findGitRoot(startPath) {
+    let current = (0, path_1.resolve)(startPath);
+    while (current !== '/') {
+        if ((0, fs_1.existsSync)((0, path_1.join)(current, '.git'))) {
+            return current;
+        }
+        const parent = (0, path_1.resolve)(current, '..');
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    return null;
+}
+// ── Main scan command ────────────────────────────────────────────────────
+async function scan(options) {
+    const startTime = Date.now();
+    const targetPath = (0, path_1.resolve)(options.path || process.cwd());
+    const isDryRun = options.dryRun ?? false;
+    const shouldCompile = options.compile ?? false;
+    console.log('');
+    console.log(chalk_1.default.cyan.bold('  ekkOS Scan'));
+    console.log(chalk_1.default.gray('  ─'.repeat(25)));
+    console.log('');
+    // Check if in a git repo
+    const gitRoot = findGitRoot(targetPath);
+    const repoRoot = gitRoot || targetPath;
+    if (gitRoot) {
+        console.log(chalk_1.default.gray(`  Git root: ${gitRoot}`));
+    }
+    else {
+        console.log(chalk_1.default.yellow(`  No git repo found — scanning ${targetPath}`));
+    }
+    console.log('');
+    // Phase 1: Scan repo structure
+    const scanSpinner = (0, ora_1.default)('Scanning repo structure...').start();
+    let systems;
+    try {
+        const rawSystems = scanDirectory(repoRoot, repoRoot, 0, 4, null);
+        systems = assignParentSystems(rawSystems);
+        scanSpinner.succeed(`Found ${chalk_1.default.bold(systems.length.toString())} systems`);
+    }
+    catch (err) {
+        scanSpinner.fail('Scan failed');
+        console.error(chalk_1.default.red(`  ${err instanceof Error ? err.message : err}`));
+        process.exit(1);
+    }
+    // Show discovered systems
+    if (systems.length > 0) {
+        console.log('');
+        // Group by domain
+        const byDomain = new Map();
+        for (const s of systems) {
+            const group = byDomain.get(s.domain) || [];
+            group.push(s);
+            byDomain.set(s.domain, group);
+        }
+        for (const [domain, entries] of byDomain) {
+            console.log(chalk_1.default.cyan(`  ${domain}`));
+            for (const s of entries) {
+                const indent = s.parent_system_id ? '    ' : '  ';
+                const arrow = s.parent_system_id ? '└─' : '──';
+                console.log(chalk_1.default.gray(`${indent}${arrow} `) + chalk_1.default.white(s.system_id) + chalk_1.default.gray(` → ${s.directory_path}`));
+            }
+        }
+        console.log('');
+    }
+    // Dry run — stop here
+    if (isDryRun) {
+        console.log(chalk_1.default.yellow('  Dry run — no changes made'));
+        const duration = ((Date.now() - startTime) / 1000).toFixed(1);
+        console.log(chalk_1.default.gray(`  Done in ${duration}s`));
+        console.log('');
+        return;
+    }
+    // Phase 2: Load API key
+    const apiKey = loadApiKey();
+    if (!apiKey) {
+        console.log(chalk_1.default.red('  No API key found.'));
+        console.log(chalk_1.default.gray('  Run `ekkos init` first, or set EKKOS_API_KEY env var.'));
+        console.log('');
+        process.exit(1);
+    }
+    // Phase 3: Seed registry via API
+    const seedSpinner = (0, ora_1.default)('Seeding registry...').start();
+    try {
+        const apiUrl = process.env.EKKOS_API_URL || platform_js_1.MCP_API_URL;
+        const response = await fetch(`${apiUrl}/api/v1/living-docs/seed`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                systems,
+                compile: shouldCompile,
+            }),
+        });
+        if (!response.ok) {
+            const errBody = await response.text();
+            seedSpinner.fail('Seed failed');
+            console.error(chalk_1.default.red(`  API returned ${response.status}: ${errBody}`));
+            process.exit(1);
+        }
+        const result = await response.json();
+        if (!result.ok) {
+            seedSpinner.fail('Seed failed');
+            console.error(chalk_1.default.red(`  ${result.error || 'Unknown error'}`));
+            process.exit(1);
+        }
+        seedSpinner.succeed(`Seeded ${chalk_1.default.bold(result.total.toString())} systems` +
+            (result.inserted > 0 ? chalk_1.default.green(` (${result.inserted} new)`) : '') +
+            (result.updated > 0 ? chalk_1.default.gray(` (${result.updated} updated)`) : ''));
+        // Show any errors
+        if (result.errors && result.errors.length > 0) {
+            console.log(chalk_1.default.yellow(`  ${result.errors.length} errors:`));
+            for (const e of result.errors.slice(0, 5)) {
+                console.log(chalk_1.default.gray(`    - ${e}`));
+            }
+            if (result.errors.length > 5) {
+                console.log(chalk_1.default.gray(`    ... and ${result.errors.length - 5} more`));
+            }
+        }
+        // Compile pass result
+        if (result.compile) {
+            if (result.compile.triggered) {
+                console.log(chalk_1.default.green('  Compile pass triggered'));
+            }
+            else {
+                console.log(chalk_1.default.yellow(`  Compile skipped: ${result.compile.reason || result.compile.error || 'unknown'}`));
+            }
+        }
+    }
+    catch (err) {
+        seedSpinner.fail('Seed failed');
+        if (err instanceof TypeError && err.cause?.code === 'ECONNREFUSED') {
+            console.error(chalk_1.default.red('  Could not connect to ekkOS API. Is it running?'));
+        }
+        else {
+            console.error(chalk_1.default.red(`  ${err instanceof Error ? err.message : err}`));
+        }
+        process.exit(1);
+    }
+    // Summary
+    const duration = ((Date.now() - startTime) / 1000).toFixed(1);
+    console.log('');
+    console.log(chalk_1.default.green(`  Done in ${duration}s`));
+    console.log('');
+}

package/dist/commands/swarm-dashboard.js

@@ -63,11 +63,12 @@ const commander_1 = require("commander");
 const state_js_1 = require("../utils/state.js");
 // ── Pricing (per MTok) ──
 const MODEL_PRICING = {
-    'claude-opus-4-6': { input: 15, output: 75, cacheWrite: 18.75, cacheRead: 1.50 },
-    'claude-opus-4-5-20250620': { input: 15, output: 75, cacheWrite: 18.75, cacheRead: 1.50 },
+    'claude-opus-4-6': { input: 5, output: 25, cacheWrite: 6.25, cacheRead: 0.50 },
+    'claude-opus-4-5-20250620': { input: 5, output: 25, cacheWrite: 6.25, cacheRead: 0.50 },
+    'claude-sonnet-4-6': { input: 3, output: 15, cacheWrite: 3.75, cacheRead: 0.30 },
     'claude-sonnet-4-5-20250929': { input: 3, output: 15, cacheWrite: 3.75, cacheRead: 0.30 },
     'claude-sonnet-4-5-20250514': { input: 3, output: 15, cacheWrite: 3.75, cacheRead: 0.30 },
-    'claude-haiku-4-5-20251001': { input: 0.80, output: 4, cacheWrite: 1.00, cacheRead: 0.08 },
+    'claude-haiku-4-5-20251001': { input: 1, output: 5, cacheWrite: 1.25, cacheRead: 0.10 },
 };
 function getModelPricing(modelId) {
     if (MODEL_PRICING[modelId])
@@ -332,11 +333,20 @@ async function launchSwarmDashboard(launchTs, refreshMs) {
     const USAGE_H = 4;
     const FOOTER_H = 3;
     const FIXED_H = HEADER_H + WORKERS_H + USAGE_H + FOOTER_H;
+    function resolveChartRatio(height) {
+        if (height >= 62)
+            return 0.22;
+        if (height >= 48)
+            return 0.25;
+        if (height >= 36)
+            return 0.28;
+        return 0.32;
+    }
     function calcLayout() {
-        const H = Math.max(30, screen.height);
+        const H = Math.max(30, screen.height || 30);
         const remaining = Math.max(10, H - FIXED_H);
-        const chartH = Math.max(CHART_H_MIN, Math.floor(remaining * 0.30));
-        const tableH = Math.max(4, remaining - chartH);
+        const chartH = Math.max(CHART_H_MIN, Math.floor(remaining * resolveChartRatio(H)));
+        const tableH = Math.max(5, remaining - chartH);
         return {
             header: { top: 0, height: HEADER_H },
             workers: { top: HEADER_H, height: WORKERS_H },
@@ -368,15 +378,20 @@ async function launchSwarmDashboard(launchTs, refreshMs) {
         border: { type: 'line' },
         label: ' Workers ',
     });
-    const tokenChart = contrib.line({
-        top: layout.chart.top, left: 0, width: W, height: layout.chart.height,
-        label: ' Tokens/Turn (K) ',
-        showLegend: true,
-        legend: { width: 12 },
-        style: { line: 'green', text: 'white', baseline: 'white', border: { fg: 'yellow' } },
-        border: { type: 'line', fg: 'yellow' },
-        xLabelPadding: 0, xPadding: 1, wholeNumbersOnly: false,
-    });
+    function createTokenChart(top, left, width, height) {
+        return contrib.line({
+            top, left, width, height,
+            label: ' Tokens/Turn (K) ',
+            showLegend: true,
+            legend: { width: 12 },
+            style: { line: 'green', text: 'white', baseline: 'white', border: { fg: 'yellow' } },
+            border: { type: 'line', fg: 'yellow' },
+            xLabelPadding: 0, xPadding: 1, wholeNumbersOnly: false,
+        });
+    }
+    let tokenChart = createTokenChart(layout.chart.top, 0, W, layout.chart.height);
+    let chartLayoutW = 0;
+    let chartLayoutH = 0;
     const turnBox = blessed.box({
         top: layout.table.top, left: 0, width: W, height: layout.table.height,
         content: '',
@@ -413,22 +428,77 @@ async function launchSwarmDashboard(launchTs, refreshMs) {
     screen.append(footerBox);
     function applyLayout() {
         layout = calcLayout();
+        const fullWidth = Math.max(24, screen.width || 80);
+        const H_PAD = 1;
+        const contentWidth = Math.max(20, fullWidth - (H_PAD * 2));
         headerBox.top = layout.header.top;
+        headerBox.left = H_PAD;
+        headerBox.width = contentWidth;
         headerBox.height = layout.header.height;
         workersBox.top = layout.workers.top;
+        workersBox.left = H_PAD;
+        workersBox.width = contentWidth;
         workersBox.height = layout.workers.height;
-        tokenChart.top = layout.chart.top;
-        tokenChart.height = layout.chart.height;
+        if (chartLayoutW !== contentWidth || chartLayoutH !== layout.chart.height) {
+            try {
+                screen.remove(tokenChart);
+            }
+            catch { }
+            try {
+                tokenChart.destroy?.();
+            }
+            catch { }
+            tokenChart = createTokenChart(layout.chart.top, H_PAD, contentWidth, layout.chart.height);
+            chartLayoutW = contentWidth;
+            chartLayoutH = layout.chart.height;
+            screen.append(tokenChart);
+        }
+        else {
+            tokenChart.top = layout.chart.top;
+            tokenChart.left = H_PAD;
+            tokenChart.width = contentWidth;
+            tokenChart.height = layout.chart.height;
+        }
         turnBox.top = layout.table.top;
+        turnBox.left = H_PAD;
+        turnBox.width = contentWidth;
         turnBox.height = layout.table.height;
         windowBox.top = layout.usage.top;
+        windowBox.left = H_PAD;
+        windowBox.width = contentWidth;
         windowBox.height = layout.usage.height;
         footerBox.top = layout.footer.top;
+        footerBox.left = H_PAD;
+        footerBox.width = contentWidth;
         footerBox.height = layout.footer.height;
+        if (lastChartSeries) {
+            try {
+                tokenChart.setData(lastChartSeries);
+            }
+            catch { }
+        }
     }
     // ── State ──
     let lastWorkers = [];
+    let lastChartSeries = null;
     let sparkleTimer;
+    let lastLayoutW = screen.width || 0;
+    let lastLayoutH = screen.height || 0;
+    function ensureLayoutSynced() {
+        const w = screen.width || 0;
+        const h = screen.height || 0;
+        if (w === lastLayoutW && h === lastLayoutH)
+            return;
+        lastLayoutW = w;
+        lastLayoutH = h;
+        try {
+            screen.realloc?.();
+        }
+        catch { }
+        applyLayout();
+    }
+    // Apply once so initial render uses the final, padded geometry.
+    applyLayout();
     // ── Logo animation ──
     function renderLogoWave() {
         try {
@@ -446,11 +516,11 @@ async function launchSwarmDashboard(launchTs, refreshMs) {
             const rawLogoLen = 14; // " ekkOS_ Swarm " roughly
             const infoStr = ` ${lastWorkers.length}W ${totalTurns}t $${totalCost.toFixed(2)} ${durStr} `;
             const rawInfoLen = infoStr.length + 1;
-            const boxW = screen.width - 2;
+            const boxW = Math.max(10, headerBox.width - 2);
             const pad = Math.max(1, boxW - rawLogoLen - rawInfoLen);
             headerBox.setLabel(logoStr + '\u2500'.repeat(pad) + infoStr);
             // Header content: task description
-            const maxW = screen.width - 6;
+            const maxW = Math.max(8, headerBox.width - 6);
             const truncTask = taskStr.length > maxW ? taskStr.slice(0, maxW - 3) + '...' : taskStr;
             headerBox.setContent(` {gray-fg}Task:{/gray-fg} ${truncTask}`);
             waveOffset = (waveOffset + 1) % WAVE_COLORS.length;
@@ -471,7 +541,7 @@ async function launchSwarmDashboard(launchTs, refreshMs) {
             workersBox.setContent(' {gray-fg}No workers detected yet...{/gray-fg}');
             return;
         }
-        const boxW = Math.max(20, screen.width - 4);
+        const boxW = Math.max(20, workersBox.width - 2);
         const WORKER_COLORS = ['magenta', 'blue', 'green', 'yellow', 'cyan', 'red', 'white', 'gray'];
         const lines = [];
         // Row 1: Worker names + context bars
@@ -510,8 +580,9 @@ async function launchSwarmDashboard(launchTs, refreshMs) {
     // ── Combined turn table ──
     function renderTurnTable(workers) {
         const WORKER_COLORS = ['magenta', 'blue', 'green', 'yellow', 'cyan', 'red', 'white', 'gray'];
-        const w = Math.max(20, screen.width - 4);
+        const w = Math.max(18, turnBox.width - 4);
         const div = '{gray-fg}|{/gray-fg}';
+        const lastScrollPerc = turnBox.getScrollPerc();
         // Columns: W(2) Turn(4) Model(7) Context(7) CacheRd(flex) CacheWr(flex) Out(flex) Cost(7)
         const colW = 2;
         const colNum = 4;
@@ -540,8 +611,7 @@ async function launchSwarmDashboard(launchTs, refreshMs) {
         }
         // Sort by timestamp descending (newest first)
         allTurns.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
-        const visibleRows = Math.max(1, layout.table.height - 4);
-        const rows = allTurns.slice(0, visibleRows).map(t => {
+        const rows = allTurns.map(t => {
             const wColor = WORKER_COLORS[(t.workerIndex - 1) % WORKER_COLORS.length];
             const mTag = modelTag(t.routedModel);
             const mColor = t.routedModel.includes('haiku') ? 'green' : t.routedModel.includes('sonnet') ? 'blue' : 'magenta';
@@ -557,6 +627,9 @@ async function launchSwarmDashboard(launchTs, refreshMs) {
                 costFlag + rpad(`$${t.cost.toFixed(2)}`, colCost) + costEnd);
         });
         turnBox.setContent([header, separator, ...rows].join('\n'));
+        if (lastScrollPerc > 0) {
+            turnBox.setScrollPerc(lastScrollPerc);
+        }
     }
     // ── Combined chart ──
     function renderChart(workers) {
@@ -576,16 +649,68 @@ async function launchSwarmDashboard(launchTs, refreshMs) {
             });
         }
         if (series.length > 0) {
+            lastChartSeries = series;
             tokenChart.setData(series);
         }
     }
     // ── Usage window (Anthropic OAuth) ──
+    function extractClaudeOauthAccessToken(rawBlob) {
+        const raw = (rawBlob || '').trim();
+        if (!raw)
+            return null;
+        const candidates = new Set([raw]);
+        if (/^[0-9a-fA-F]+$/.test(raw) && raw.length % 2 === 0) {
+            const decoded = Buffer.from(raw, 'hex').toString('utf8');
+            candidates.add(decoded);
+            candidates.add(decoded.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, '').trim());
+        }
+        for (const candidate of candidates) {
+            if (!candidate)
+                continue;
+            try {
+                const parsed = JSON.parse(candidate);
+                const token = parsed?.claudeAiOauth?.accessToken;
+                if (typeof token === 'string' && token.length > 0)
+                    return token;
+            }
+            catch { }
+            try {
+                const parsed = JSON.parse(`{${candidate}}`);
+                const token = parsed?.claudeAiOauth?.accessToken;
+                if (typeof token === 'string' && token.length > 0)
+                    return token;
+            }
+            catch { }
+            const oauthMatch = candidate.match(/"claudeAiOauth"\s*:\s*(\{[\s\S]*?\})/);
+            if (oauthMatch) {
+                try {
+                    const oauth = JSON.parse(oauthMatch[1]);
+                    const token = oauth?.accessToken;
+                    if (typeof token === 'string' && token.length > 0)
+                        return token;
+                }
+                catch { }
+                const tokenMatch = oauthMatch[1].match(/"accessToken"\s*:\s*"([^"]+)"/);
+                if (tokenMatch?.[1])
+                    return tokenMatch[1];
+            }
+        }
+        return null;
+    }
     async function fetchAnthropicUsage() {
         try {
-            const { execSync } = require('child_process');
-            const credsJson = execSync('security find-generic-password -s "Claude Code-credentials" -w', { encoding: 'utf-8', timeout: 5000 }).trim();
-            const creds = JSON.parse(credsJson);
-            const token = creds?.claudeAiOauth?.accessToken;
+            let token = null;
+            if (process.platform === 'darwin') {
+                const { execSync } = require('child_process');
+                const credsBlob = execSync('security find-generic-password -s "Claude Code-credentials" -w', { encoding: 'utf-8', timeout: 5000 }).trim();
+                token = extractClaudeOauthAccessToken(credsBlob);
+            }
+            if (!token) {
+                const credsPath = path.join(os.homedir(), '.claude', '.credentials.json');
+                if (fs.existsSync(credsPath)) {
+                    token = extractClaudeOauthAccessToken(fs.readFileSync(credsPath, 'utf-8'));
+                }
+            }
             if (!token)
                 return null;
             const resp = await fetch('https://api.anthropic.com/api/oauth/usage', {
@@ -664,6 +789,7 @@ async function launchSwarmDashboard(launchTs, refreshMs) {
     // ── Main update loop ──
     function updateDashboard() {
         try {
+            ensureLayoutSynced();
             const workers = discoverWorkers(launchTs);
             lastWorkers = workers;
             renderWorkerCards(workers);
@@ -691,7 +817,9 @@ async function launchSwarmDashboard(launchTs, refreshMs) {
     screen.on('resize', () => {
         try {
             screen.realloc?.();
-            applyLayout();
+            lastLayoutW = 0;
+            lastLayoutH = 0;
+            ensureLayoutSynced();
             updateDashboard();
         }
         catch { }