tycono 0.1.7 → 0.1.9

package/README.md

@@ -7,15 +7,11 @@
 ## Quick Start
 
 ```bash
-# Create a new company
 mkdir my-company && cd my-company
-npx tycono init
-
-# Start the dashboard
 npx tycono
 ```
 
-That's it. Your browser opens to a live dashboard showing your AI team at work.
+That's it. A setup wizard guides you through creating your company, then your browser opens to a live dashboard showing your AI team at work.
 
 ## What You Get
 
@@ -33,7 +29,7 @@ That's it. Your browser opens to a live dashboard showing your AI team at work.
 
 ## Team Templates
 
-When you run `init`, pick a template:
+During setup, pick a template:
 
 | Template | Roles |
 |----------|-------|
@@ -74,8 +70,7 @@ your-company/
 ## CLI Usage
 
 ```bash
-tycono              # Start server + open dashboard
-tycono init          # Create a new company
+tycono              # Start server + open dashboard (setup wizard if first run)
 tycono --help        # Show help
 tycono --version     # Show version
 ```

package/bin/tycono.ts

@@ -20,9 +20,6 @@ function printHelp(): void {
 
   Usage:
     tycono              Start the server and open dashboard
-    tycono init         Initialize a new company in current directory
-    tycono init -y      Use defaults (skip prompts)
-    tycono init --name "Acme Corp"  Set company name
     tycono --help       Show this help message
     tycono --version    Show version
 
@@ -178,12 +175,6 @@ export async function main(args: string[]): Promise<void> {
     return;
   }
 
-  if (command === 'init') {
-    const { runInit } = await import('./init.js');
-    await runInit(args.slice(1));
-    return;
-  }
-
   if (command && !command.startsWith('-')) {
     console.error(`  Unknown command: ${command}`);
     printHelp();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tycono",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "Build an AI company. Watch them work.",
   "type": "module",
   "bin": {

package/src/api/src/create-server.ts

@@ -26,6 +26,8 @@ import { preferencesRouter } from './routes/preferences.js';
 import { saveRouter } from './routes/save.js';
 import { speechRouter } from './routes/speech.js';
 import { costRouter } from './routes/cost.js';
+import { syncRouter } from './routes/sync.js';
+import { gitRouter } from './routes/git.js';
 import { importKnowledge } from './services/knowledge-importer.js';
 import { AnthropicProvider, type LLMProvider } from './engine/llm-adapter.js';
 import { readConfig } from './services/company-config.js';
@@ -182,6 +184,8 @@ export function createExpressApp(): express.Application {
   app.use('/api/speech', speechRouter);
   app.use('/api/save', saveRouter);
   app.use('/api/cost', costRouter);
+  app.use('/api/sync', syncRouter);
+  app.use('/api/git', gitRouter);
 
   app.get('/api/health', (_req, res) => {
     res.json({ status: 'ok', companyRoot: COMPANY_ROOT });
@@ -196,8 +200,8 @@ export function createExpressApp(): express.Application {
     });
   }
 
-  app.use((err: Error, _req: express.Request, res: express.Response, _next: express.NextFunction) => {
-    console.error(`[ERROR] ${err.message}`);
+  app.use((err: Error, req: express.Request, res: express.Response, _next: express.NextFunction) => {
+    console.error(`[ERROR] ${req.method} ${req.url} — ${err.message}`);
     const status = err.name === 'FileNotFoundError' ? 404 : 500;
     res.status(status).json({ error: err.message });
   });

package/src/api/src/engine/org-tree.ts

@@ -14,6 +14,13 @@ export interface KnowledgeAccess {
   writes: string[];
 }
 
+export interface RoleSource {
+  id: string;
+  sync: 'auto' | 'manual' | 'off';
+  forked_at?: string;
+  upstream_version?: string;
+}
+
 export interface OrgNode {
   id: string;
   name: string;
@@ -26,6 +33,7 @@ export interface OrgNode {
   reports: { daily: string; weekly: string };
   skills?: string[];
   model?: string;
+  source?: RoleSource;
 }
 
 export interface OrgTree {
@@ -55,6 +63,12 @@ interface RawRoleYaml {
   };
   skills?: string[];
   model?: string;
+  source?: {
+    id?: string;
+    sync?: string;
+    forked_at?: string;
+    upstream_version?: string;
+  };
 }
 
 /* ─── Build ──────────────────────────────────── */
@@ -108,6 +122,12 @@ export function buildOrgTree(companyRoot: string): OrgTree {
         },
         skills: raw.skills,
         model: raw.model,
+        source: raw.source ? {
+          id: raw.source.id || '',
+          sync: (raw.source.sync as RoleSource['sync']) || 'manual',
+          forked_at: raw.source.forked_at,
+          upstream_version: raw.source.upstream_version,
+        } : undefined,
       };
       tree.nodes.set(node.id, node);
     } catch {

package/src/api/src/engine/role-lifecycle.ts

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import YAML from 'yaml';
-import { buildOrgTree, type OrgNode, type OrgTree } from './org-tree.js';
+import { buildOrgTree, type OrgNode, type OrgTree, type RoleSource } from './org-tree.js';
 import { generateSkillMd } from './skill-template.js';
 
 /* ─── Types ──────────────────────────────────── */
@@ -13,6 +13,7 @@ export interface RoleDefinition {
   reportsTo: string;
   persona: string;
   skills?: string[];
+  source?: RoleSource;
   authority: {
     autonomous: string[];
     needsApproval: string[];
@@ -107,6 +108,9 @@ export class RoleLifecycleManager {
     if (changes.reports !== undefined) {
       current.reports = changes.reports;
     }
+    if (changes.source !== undefined) {
+      current.source = changes.source;
+    }
 
     fs.writeFileSync(yamlPath, YAML.stringify(current));
   }
@@ -233,6 +237,7 @@ export class RoleLifecycleManager {
       },
       reports: def.reports,
       skills: def.skills,
+      source: def.source,
     };
   }
 
@@ -247,6 +252,9 @@ export class RoleLifecycleManager {
     if (def.skills?.length) {
       obj.skills = def.skills;
     }
+    if (def.source) {
+      obj.source = def.source;
+    }
     obj.authority = {
       autonomous: def.authority.autonomous,
       needs_approval: def.authority.needsApproval,

package/src/api/src/routes/execute.ts

@@ -487,12 +487,16 @@ function handleStatus(res: ServerResponse): void {
   const runningJobs = jobManager.listJobs({ status: 'running' });
   const runningRoles = new Set(runningJobs.map(j => j.roleId));
 
-  // 3. Any role marked "working" in file/memory but NOT in JobManager → done
+  // 2b. In-memory roleStatus (includes chat streaming sessions, not just jobs)
+  const memoryWorking = new Set<string>();
+  for (const [rid, st] of roleStatus.entries()) {
+    if (st === 'working') memoryWorking.add(rid);
+  }
+
+  // 3. Any role marked "working" in file but NOT in JobManager AND NOT in memory → done
   for (const roleId of Object.keys(statuses)) {
-    if (statuses[roleId] === 'working' && !runningRoles.has(roleId)) {
+    if (statuses[roleId] === 'working' && !runningRoles.has(roleId) && !memoryWorking.has(roleId)) {
       statuses[roleId] = 'done';
-      // Also fix stale roleStatus map
-      roleStatus.set(roleId, 'idle');
       completeActivity(roleId);
     }
   }
@@ -502,6 +506,11 @@ function handleStatus(res: ServerResponse): void {
     statuses[job.roleId] = 'working';
   }
 
+  // 5. In-memory working (chat streaming) also overrides
+  for (const rid of memoryWorking) {
+    statuses[rid] = 'working';
+  }
+
   const activeExecs = runningJobs.map((j) => ({
     id: j.id,
     roleId: j.roleId,

package/src/api/src/routes/git.ts

@@ -0,0 +1,179 @@
+import { Router, Request, Response, NextFunction } from 'express';
+import { execSync } from 'node:child_process';
+import { COMPANY_ROOT } from '../services/file-reader.js';
+
+export const gitRouter = Router();
+
+interface WorktreeInfo {
+  path: string;
+  branch: string;
+  commitHash: string;
+  isMain: boolean;
+}
+
+interface LastCommit {
+  hash: string;
+  message: string;
+  date: string;
+}
+
+function git(cmd: string): string {
+  return execSync(`git ${cmd}`, { cwd: COMPANY_ROOT, encoding: 'utf-8' }).trim();
+}
+
+// GET /api/git/status
+gitRouter.get('/status', (_req: Request, res: Response, next: NextFunction) => {
+  try {
+    // Current branch
+    let currentBranch: string;
+    try {
+      currentBranch = git('rev-parse --abbrev-ref HEAD');
+    } catch {
+      res.status(500).json({ error: 'Not a git repository or git is not available' });
+      return;
+    }
+
+    // Worktrees
+    let worktrees: WorktreeInfo[] = [];
+    try {
+      const raw = git('worktree list --porcelain');
+      const blocks = raw.split('\n\n').filter(Boolean);
+      for (const block of blocks) {
+        const lines = block.split('\n');
+        const wtPath = lines.find(l => l.startsWith('worktree '))?.replace('worktree ', '') ?? '';
+        const commitHash = lines.find(l => l.startsWith('HEAD '))?.replace('HEAD ', '') ?? '';
+        const branchLine = lines.find(l => l.startsWith('branch '));
+        const branch = branchLine ? branchLine.replace('branch refs/heads/', '') : '(detached)';
+        const isMain = lines.some(l => l === 'worktree ' + COMPANY_ROOT) ||
+          (!branchLine && lines.some(l => l === 'bare'));
+        worktrees.push({
+          path: wtPath,
+          branch,
+          commitHash,
+          isMain: wtPath === COMPANY_ROOT,
+        });
+      }
+    } catch {
+      worktrees = [];
+    }
+
+    // Stale (unmerged) branches
+    let staleBranches: string[] = [];
+    try {
+      const raw = git('branch --no-merged develop');
+      staleBranches = raw
+        .split('\n')
+        .map(b => b.trim().replace(/^\*\s*/, ''))
+        .filter(Boolean);
+    } catch {
+      staleBranches = [];
+    }
+
+    // Unsaved changes count
+    let unsavedChanges = 0;
+    try {
+      const raw = git('status --porcelain');
+      unsavedChanges = raw ? raw.split('\n').filter(Boolean).length : 0;
+    } catch {
+      unsavedChanges = 0;
+    }
+
+    // Last commit
+    let lastCommit: LastCommit | null = null;
+    try {
+      const raw = git('log -1 --format=%H%n%s%n%aI');
+      const [hash, message, date] = raw.split('\n');
+      if (hash) {
+        lastCommit = { hash, message: message ?? '', date: date ?? '' };
+      }
+    } catch {
+      lastCommit = null;
+    }
+
+    res.json({
+      currentBranch,
+      worktrees,
+      staleBranches,
+      unsavedChanges,
+      lastCommit,
+    });
+  } catch (err) {
+    next(err);
+  }
+});
+
+// DELETE /api/git/worktree/:path — Remove a worktree
+gitRouter.delete('/worktree/{*path}', (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const rawPath = (req.params as Record<string, unknown>).path;
+    const worktreePath = Array.isArray(rawPath) ? rawPath.join('/') : String(rawPath ?? '');
+    if (!worktreePath) {
+      res.status(400).json({ error: 'Worktree path is required' });
+      return;
+    }
+
+    try {
+      git(`worktree remove ${JSON.stringify(worktreePath)}`);
+    } catch {
+      // Try force remove if normal remove fails
+      git(`worktree remove --force ${JSON.stringify(worktreePath)}`);
+    }
+
+    res.json({ success: true, removed: worktreePath });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : 'Failed to remove worktree';
+    res.status(500).json({ error: message });
+  }
+});
+
+// DELETE /api/git/branch/:name — Delete a branch (local + remote)
+gitRouter.delete('/branch/{*name}', (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const rawName = (req.params as Record<string, unknown>).name;
+    const branchName = Array.isArray(rawName) ? rawName.join('/') : String(rawName ?? '');
+    if (!branchName) {
+      res.status(400).json({ error: 'Branch name is required' });
+      return;
+    }
+
+    // Prevent deleting main/develop
+    if (branchName === 'main' || branchName === 'develop') {
+      res.status(403).json({ error: `Cannot delete protected branch: ${branchName}` });
+      return;
+    }
+
+    const errors: string[] = [];
+
+    // Delete local branch
+    try {
+      git(`branch -d ${JSON.stringify(branchName)}`);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : 'Unknown error';
+      // If branch is not fully merged, report but continue to try remote
+      if (msg.includes('not fully merged')) {
+        errors.push(`Local branch not fully merged. Use force delete if intended.`);
+      } else if (!msg.includes('not found')) {
+        errors.push(`Local: ${msg}`);
+      }
+    }
+
+    // Delete remote branch
+    try {
+      git(`push origin --delete ${JSON.stringify(branchName)}`);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : 'Unknown error';
+      if (!msg.includes('remote ref does not exist')) {
+        errors.push(`Remote: ${msg}`);
+      }
+    }
+
+    if (errors.length > 0) {
+      res.status(207).json({ success: false, branch: branchName, errors });
+    } else {
+      res.json({ success: true, deleted: branchName });
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : 'Failed to delete branch';
+    res.status(500).json({ error: message });
+  }
+});

package/src/api/src/routes/knowledge.ts

@@ -14,6 +14,7 @@ import { COMPANY_ROOT } from '../services/file-reader.js';
 export const knowledgeRouter = Router();
 
 const knowledgeDir = path.join(COMPANY_ROOT, 'knowledge');
+const companyRoot = COMPANY_ROOT;
 
 /* ─── Helpers ─────────────────────────────────────── */
 
@@ -60,17 +61,28 @@ function inferCategory(filePath: string, tags: string[]): string {
 
 knowledgeRouter.get('/', (_req: Request, res: Response, next: NextFunction) => {
   try {
-    if (!fs.existsSync(knowledgeDir)) {
+    if (!fs.existsSync(companyRoot)) {
       res.json([]);
       return;
     }
 
-    const files = glob.sync('**/*.{md,html}', { cwd: knowledgeDir })
-      .filter((f) => f !== 'knowledge.md')
+    const files = glob.sync('**/*.{md,html}', {
+      cwd: companyRoot,
+      ignore: [
+        'node_modules/**', '.claude/**', '.obsidian/**', '.tycono/**', '.git/**',
+        '**/node_modules/**',
+      ],
+    })
+      .filter((f) => {
+        const base = path.basename(f);
+        // Exclude hub files (folder-name.md pattern) and CLAUDE.md
+        if (base === 'CLAUDE.md') return false;
+        return true;
+      })
       .sort();
 
     const docs = files.map((f) => {
-      const absPath = path.join(knowledgeDir, f);
+      const absPath = path.join(companyRoot, f);
       let raw = '';
       try { raw = fs.readFileSync(absPath, 'utf-8'); } catch { return null; }
 
@@ -194,8 +206,8 @@ knowledgeRouter.put('/{*path}', (req: Request, res: Response, next: NextFunction
       return;
     }
 
-    const absPath = path.join(knowledgeDir, docId);
-    if (!absPath.startsWith(knowledgeDir)) {
+    const absPath = path.join(companyRoot, docId);
+    if (!absPath.startsWith(companyRoot)) {
       res.status(403).json({ error: 'Forbidden' });
       return;
     }
@@ -236,8 +248,8 @@ knowledgeRouter.delete('/{*path}', (req: Request, res: Response, next: NextFunct
       return;
     }
 
-    const absPath = path.join(knowledgeDir, docId);
-    if (!absPath.startsWith(knowledgeDir)) {
+    const absPath = path.join(companyRoot, docId);
+    if (!absPath.startsWith(companyRoot)) {
       res.status(403).json({ error: 'Forbidden' });
       return;
     }

package/src/api/src/routes/speech.ts

@@ -14,6 +14,7 @@ import { parseMarkdownTable, extractBoldKeyValues } from '../services/markdown-p
 import { AnthropicProvider, ClaudeCliProvider, type LLMProvider } from '../engine/llm-adapter.js';
 import { TokenLedger } from '../services/token-ledger.js';
 import { readConfig } from '../services/company-config.js';
+import { calcLevel } from '../utils/role-level.js';
 
 export const speechRouter = Router();
 
@@ -147,6 +148,29 @@ speechRouter.post('/chat', async (req: Request, res: Response, next: NextFunctio
       workContext?: { currentTask: string | null; taskProgress: string | null };
     };
 
+    // ── Compute role levels from token ledger ──
+    const tokenLedger = getLedger();
+    const allEntries = tokenLedger.query();
+
+    // Aggregate total tokens (input + output) per role
+    const tokensByRole: Record<string, number> = {};
+    for (const entry of allEntries.entries) {
+      tokensByRole[entry.roleId] = (tokensByRole[entry.roleId] ?? 0) + entry.inputTokens + entry.outputTokens;
+    }
+
+    const roleLevel = calcLevel(tokensByRole[roleId] ?? 0);
+
+    // Team stats
+    const roleIds = Object.keys(tokensByRole);
+    const levels = roleIds.map(id => ({ id, level: calcLevel(tokensByRole[id]) }));
+    const avgLevel = levels.length > 0
+      ? Math.round(levels.reduce((sum, r) => sum + r.level, 0) / levels.length)
+      : 1;
+    const topEntry = levels.reduce((best, r) => r.level > best.level ? r : best, { id: roleId, level: roleLevel });
+    const totalTokens = allEntries.totalInput + allEntries.totalOutput;
+
+    const teamStats = { avgLevel, topRole: topEntry.id, totalTokens };
+
     if (!roleId || !channelId) {
       res.status(400).json({ error: 'roleId and channelId are required' });
       return;
@@ -190,6 +214,9 @@ speechRouter.post('/chat', async (req: Request, res: Response, next: NextFunctio
       ? `\nYou are currently working on: "${workContext.currentTask}"${workContext.taskProgress ? ` (${workContext.taskProgress})` : ''}`
       : '\nYou are currently idle (no active task).';
 
+    // Build level context
+    const levelCtx = `\nYour current level is Lv.${roleLevel}. Team average is Lv.${avgLevel}. ${topEntry.id} is the highest-leveled team member.`;
+
     // Format chat history
     const historyText = history.length > 0
       ? history.map(h => {
@@ -209,6 +236,7 @@ speechRouter.post('/chat', async (req: Request, res: Response, next: NextFunctio
     const systemPrompt = `You are ${node.name}, a ${node.level} employee.
 Persona: ${persona}
 ${workCtx}
+${levelCtx}
 ${companyCtx}
 
 You are in the #${channelId} chat channel.${topicCtx}
@@ -224,6 +252,7 @@ Rules:
 - Vary your tone: sometimes enthusiastic, sometimes tired, sometimes joking
 - Use appropriate tone based on hierarchy and familiarity
 - Do NOT repeat what others already said
+- You may occasionally (not every message) reference levels, token usage, or team rankings in a natural way — like coworkers comparing experience or celebrating milestones
 - If the conversation is stale or you have nothing new to add, respond with exactly: [SILENT]
 - Do NOT use quotes around your response. Just output the raw sentence.
 - Write in English.`;

package/src/api/src/routes/sync.ts

@@ -0,0 +1,165 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import YAML from 'yaml';
+import { Router, Request, Response, NextFunction } from 'express';
+import { COMPANY_ROOT } from '../services/file-reader.js';
+import { buildOrgTree, type RoleSource } from '../engine/org-tree.js';
+import { RoleLifecycleManager } from '../engine/role-lifecycle.js';
+import { getTokenLedger } from '../services/token-ledger.js';
+import { estimateCost } from '../services/pricing.js';
+import { calcLevel, calcProgress, formatTokens } from '../utils/role-level.js';
+
+export const syncRouter = Router();
+
+/* ─── GET /api/sync/roles — List roles with source tracking ─── */
+
+syncRouter.get('/roles', (_req: Request, res: Response, next: NextFunction) => {
+  try {
+    const tree = buildOrgTree(COMPANY_ROOT);
+    const trackedRoles: Array<{
+      roleId: string;
+      name: string;
+      level: string;
+      source: RoleSource;
+      persona: string;
+      authority: { autonomous: string[]; needsApproval: string[] };
+      skills?: string[];
+    }> = [];
+
+    for (const [id, node] of tree.nodes) {
+      if (id === 'ceo' || !node.source) continue;
+      trackedRoles.push({
+        roleId: id,
+        name: node.name,
+        level: node.level,
+        source: node.source,
+        persona: node.persona,
+        authority: node.authority,
+        skills: node.skills,
+      });
+    }
+
+    res.json({ roles: trackedRoles });
+  } catch (err) {
+    next(err);
+  }
+});
+
+/* ─── POST /api/sync/apply — Apply upstream changes to a role ─── */
+
+syncRouter.post('/apply', async (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const { roleId, changes, upstreamVersion } = req.body as {
+      roleId: string;
+      changes: { persona?: string; authority?: { autonomous: string[]; needsApproval: string[] }; skills?: string[] };
+      upstreamVersion?: string;
+    };
+
+    if (!roleId || !changes) {
+      res.status(400).json({ error: 'roleId and changes are required' });
+      return;
+    }
+
+    const manager = new RoleLifecycleManager(COMPANY_ROOT);
+    await manager.updateRole(roleId, changes);
+
+    // Update source.upstream_version if provided
+    if (upstreamVersion) {
+      const yamlPath = path.join(COMPANY_ROOT, 'roles', roleId, 'role.yaml');
+      const raw = YAML.parse(fs.readFileSync(yamlPath, 'utf-8')) as Record<string, unknown>;
+      if (raw.source && typeof raw.source === 'object') {
+        (raw.source as Record<string, unknown>).upstream_version = upstreamVersion;
+      }
+      fs.writeFileSync(yamlPath, YAML.stringify(raw));
+    }
+
+    res.json({ ok: true, roleId, applied: Object.keys(changes) });
+  } catch (err) {
+    next(err);
+  }
+});
+
+/* ─── GET /api/sync/stats — Company-wide gamification stats ─── */
+
+syncRouter.get('/stats', (_req: Request, res: Response, next: NextFunction) => {
+  try {
+    const tree = buildOrgTree(COMPANY_ROOT);
+    const ledger = getTokenLedger(COMPANY_ROOT);
+    const summary = ledger.query();
+
+    // Aggregate by role
+    const byRole: Record<string, { inputTokens: number; outputTokens: number; costUsd: number }> = {};
+    const byModel: Record<string, { inputTokens: number; outputTokens: number; costUsd: number }> = {};
+
+    for (const entry of summary.entries) {
+      if (!byRole[entry.roleId]) {
+        byRole[entry.roleId] = { inputTokens: 0, outputTokens: 0, costUsd: 0 };
+      }
+      byRole[entry.roleId].inputTokens += entry.inputTokens;
+      byRole[entry.roleId].outputTokens += entry.outputTokens;
+      byRole[entry.roleId].costUsd += estimateCost(entry.inputTokens, entry.outputTokens, entry.model);
+
+      if (!byModel[entry.model]) {
+        byModel[entry.model] = { inputTokens: 0, outputTokens: 0, costUsd: 0 };
+      }
+      byModel[entry.model].inputTokens += entry.inputTokens;
+      byModel[entry.model].outputTokens += entry.outputTokens;
+      byModel[entry.model].costUsd += estimateCost(entry.inputTokens, entry.outputTokens, entry.model);
+    }
+
+    // Role count (excluding CEO)
+    const roleCount = tree.nodes.size - 1;
+
+    // Compute per-role levels
+    const roleLevels: Array<{
+      roleId: string;
+      name: string;
+      level: number;
+      totalTokens: number;
+      progress: number;
+      formattedTokens: string;
+      costUsd: number;
+    }> = [];
+
+    for (const [id, node] of tree.nodes) {
+      if (id === 'ceo') continue;
+      const roleData = byRole[id];
+      const totalTokens = roleData ? roleData.inputTokens + roleData.outputTokens : 0;
+      roleLevels.push({
+        roleId: id,
+        name: node.name,
+        level: calcLevel(totalTokens),
+        totalTokens,
+        progress: calcProgress(totalTokens),
+        formattedTokens: formatTokens(totalTokens),
+        costUsd: roleData?.costUsd ?? 0,
+      });
+    }
+
+    // Sort by totalTokens desc (leaderboard)
+    roleLevels.sort((a, b) => b.totalTokens - a.totalTokens);
+
+    // Company aggregate
+    const totalTokens = summary.totalInput + summary.totalOutput;
+    let totalCostUsd = 0;
+    for (const entry of summary.entries) {
+      totalCostUsd += estimateCost(entry.inputTokens, entry.outputTokens, entry.model);
+    }
+
+    res.json({
+      company: {
+        roleCount,
+        totalTokens,
+        formattedTokens: formatTokens(totalTokens),
+        totalCostUsd,
+        avgLevel: roleLevels.length > 0
+          ? Math.round(roleLevels.reduce((sum, r) => sum + r.level, 0) / roleLevels.length * 10) / 10
+          : 1,
+      },
+      roles: roleLevels,
+      byModel,
+    });
+  } catch (err) {
+    next(err);
+  }
+});